Przeszukaj forum

Witam Od około półtora roku interesuję się sztuczną inteligencją, zwłaszcza zastosowaną w robotyce. Jest to dla mnie niezwykle ciekawy temat Kilka miesięcy temu zacząłem pracować nad moim prywatnym projektem, który cały czas jest w fazie rozwoju. Pewne elementy, takie jak uczenie się poprzez rozmowę z człowiekiem są gotowe, więc postanowiłem nagrać poniższe filmy: AgeBot podłączony jest do internetu. Platforma to gotowa konstrukcja - AlphaBot-PI. Użyłem jej, aby szybciej skupić się na oprogramowaniu. W ostatnim czasie domykałem widoczne na filmach możliwości robota i w międzyczasie zacząłem pracę nad wykorzystaniem kamery (aktualny stan to ~30%). W bliskiej przyszłości platformę mam zamiar wymienić na coś bardziej zaawansowanego lub zbudować swoją, ponieważ ta zaczyna mnie powoli ograniczać (pod względem hardware'u). Jej specyfikacja dostępna jest w internecie (np. na stronie firmy Waveshare), więc nie będę kopiował Jak już zauważyliście - używam Raspberry PI. Oprogramowanie na malinkę napisałem w C++, pozostała część to C++ oraz Python. Systemem jest Raspbian. Do zautomatyzowania instalacji niektórych zależności w systemie (akurat w przypadku samej malinki) używam narzędzia Ansible, a o te krytyczne dla działania aplikacji dba manager pakietów (apt, buduję paczki .deb). Do przetwarzania tekstu użyłem biblioteki Tensorflow, natomiast w procesie uczenia się, robotowi asystuje wnioskowanie. Kamera i przetwarzanie obrazu otworzy wiele nowych drzwi, ułatwi również pracę przy kolejnej domenie - planowaniu zadań. Sam robot jest stosunkowo małą częścią projektu, ale o tym... w przyszłości Każdy feedback mile widziany Pozdrawiam PS: W ciągu kilku dni napiszę posta z trochę bardziej szczegółowymi informacjami odnośnie przetwarzania tekstu - czatowania z robotem

Witam, Na sprzedaż posiadam dużą ilość elektroniki związanej z budowaniem układów na arduino / malince. Studiowałem AiR i wiadomo, podczas studiów człowiek się trochę bawił, lecz teraz przy normalnej pracy nie mam już czasu/chęci. Nie sposób wymienić wszystkich elementów, które tutaj są ale z ciekawszych: - rasberry pi 3, z zasilaczem, kartą pamięci, modułem kamery itd. - klony arduino, czujniki wagi, odległości, joystik, klawiaturki itd. - wiele wiele pierdół, rezystorów, kabli, - akcesoria do lutowania Link do zdjęć ze wszystkimi elementami: https://drive.google.com/drive/folders/1GeEhGKALeyMzg0ZHvzhuuUFbM4BgsNpj?usp=sharing Cena: 300zł Ze względu na ilość tych wszystkich rzeczy preferowałbym odbiór osobisty w Poznaniu, ale jestem w stanie również to wysłać. W razie co proszę o kontakt na telefon: 781358758 Nie wiem gdzie mam wstawić ten post, jestem tutaj nowy. Mam nadzieję, że nie łamię regulaminu. Chcę po prostu komuś oddać praktycznie nowy zestaw do zabawy bo ja już nie potrzebuję.

Witam, Na wstępie zaznaczam, że w tematyce mikrokontrolerów jestem początkujący i proszę o wyrozumiałość Mam potrzebę stworzyć system bazujący na RFID, którego zadaniem jest odczyt pomiaru czasu okrążeń pokonywanych rowerem. Dodam, że odczyt ten miałby być zapisywany do bazy danych, z której można by później wyświetlić indywidualne wyniki dla każdego zawodnika. Myślałem o zastosowaniu Raspberry Pi z uwagi na możliwość stworzenia serwera, jednak mam zagadkę co do doboru samego RFID. Musiałby on dobierać sygnał z odbiornika na odległość 1-1.5m z dość dużą dokładnością. Czy możecie polecić jakiś zestaw spełniający te wymagania i który nie zrujnuje mnie finansowo? Ma to w ogóle jakiś sens? Dziękuję za pomoc i pozdrawiam.

Jestem tu nowy, więc proszę o wyrozumiałość. Próbowałem szukać czegoś podobnego na forum, ale bezskutecznie. Bardzo proszę o pomoc w kwestii zabrania się do wykonania następującego projektu. Mam Rpi 4, przeczytałem dostępne poradniki dotyczące Raspberry Pi, ale nie wiem, jak ruszyć. Chciałbym móc przy pomocy Rpi i Domoticza: - otwierać i zamykać bramę wjazdową na posesję, - móc sprawdzić będąc poza domem, czy jest ona zamknięta lub otwarta, oraz zmienić w razie potrzeby ten stan. Obecnie otwieranie i zamykanie jest wykonywane za pomocą pilota bramowego, a ponadto jest możliwość wykonania tego przy pomocy przycisku unifonu. Kupiłem kilka modułów ESP, jednak nie wiem, czego potrzebuję jeszcze i jak to wykonać? Zdaję sobie sprawę, że to może trochę jak porywanie się z motyką na słońce, ale chciałbym na początek zrobić coś namacalnego własnymi siłami i przy wydatnej pomocy szanownych forumowiczów. Mam czas, chęci i samozaparcie, chociaż jestem początkujący. Od czego zacząć?

Witam, Chciałbym prosić o pomoc w dopasowaniu oraz znalezieniu elementów do projektu który robię. Mianowicie, w projekcie użył bym kilku wentylatorów, ledów oraz czujników (Chodzi o cyrkulacje powietrza w pokoju i jednoczesne zmniejszenie temperatury) możliwe też że wyświetlacza LCD. Oczywiście chciałbym sterować tym z rpi, a z racji tego że dopiero rozpoczynam przygodę - prosił bym o pomoc w znalezieniu niezbędnych elementów które pomogą mi zrealizować projekt.

Hej, Zacząłem bawić się z małą szklarnią obsługiwaną przez Raspberry Pi, jako że w szklarni temperatura może być za duża to chciałbym aby była możliwość chłodzenia/odciągania wilgoci powietrza. Mam już zrobioną obsługę czytania wartości z czujników temperatury, wilgotności gleby i wilgotności powietrza. Teraz zostało mi ogarnięcie pompki (5V) do nawodnienia i dwóch wentylatorków: 1 który wydmuchuje powietrze z zewnątrz - chłodzenie a drugi który wdmuchuje - wilgoć (1x12V a drugi planuje użyć ze starego kompa, jeszcze go nie posiadam). Posiadam: Wentylator: PF4010D12HS 12V 0.12A Tranzystory 2N7000 Tranzystory 2N3904 Pompka: https://allegro.pl/oferta/pompka-zanurzeniowa-5v-biala-zta31509-8151984645?snapshot=MjAyMC0wNy0wMlQxMDozNzoxOS40NzRaO2J1eWVyOzlkY2RmNjNhYTk0OTAyMDUwYjgzYWY2ZjM0NjI4ODI5N2U3YTI4NzUwYjMwNTFjYTAxYWE0YTdiNWIzNDdmN2U%3D Wszystko co do tej pory podłączyłem (2x czujnik wilgotnosci gleby, 2x czujnik temp/wilg powietrza, przycisk 'emergency' który zatrzymuje program + świeci diodą) działa na zasilaniu 3.3V z malinki. Teraz chciałbym podpiąć rzeczy na 5V. Wiatraczek podpięty bezpośrednio pod 5V działa (nie z najlepszymi rpm ale zupełnie wystarczająco), tak samo pompka. Czy mógłby ktoś pomóc z ogarnięciem podłączenia ww. elementów? Z góry dzieki [EDIT] oczywiście chodzi o podłączenie tych elementów z możliwością sterowania poprzez porty malinkowe

Raspberry Pi jest często używane jako kontroler automatyki domowej. Inteligentne sterowanie roletami i oświetleniem to mały wycinek tego co potrafi malinka z Domoticzem. Na początku warto zacząć od ustawień systemu, podłączenia czujników temperatury (DS18B20) oraz konfiguracji powiadomień. [blog]https://forbot.pl/blog/kurs-raspberry-pi-projekty-domoticz-ds18b20-maile-id27526[/blog]

Cześć! Zastanawiam się jakich programów używacie do pisania skryptów w Python. Jak wiadomo, język ten jest ekstremalnie wrażliwy na wszelkie białe znaki, więc dobry edytor to podstawa. Obecnie używam domyślnego Thonny Python IDE, lecz chciałbym mieć auto-uzupełnienie/podgląd do obiektów i metod. Zainstalowałem PyCharm, lecz nie do końca rozumiem dlaczego nie mogę importować bibliotek potrzebnych do mojego programu - unable to import module. Fajnie jakbyście podzielili się czego Wy używacie.

Cześć, przymierzam się do projektu inteligentnego domu, mam w głowie zarys planu tego co chcę osiągnąć, ale ze względu na niewielkie doświadczenie z elektroniką będę bardzo wdzięczny za wszelkie rady i sugestie. Ogólna koncepcja jest taka: Serwer na Raspberry Pi zbierający dane z czujników i wysyłający komendy do elementów wykonawczych. Czujniki i elementy wykonawcze rozproszone po całym mieszkaniu (i poza nim ) W pierwszej kolejności chciałbym zacząć od kilku prostych czujników i łączenia się do nich z mojego komputera (na razie bez serwera na malince). Myślałem o tym żeby czujniki wyposażać w esp8266 i łączyć się do nich po HTTP. W przyszłości, jak powstałby serwer na Raspberry Pi, to mógłby odpytywać czujniki i zbierać dane. Jeśli chodzi o zasilanie czujników to myślałem o zasilaniu bateryjnym/akumulatorowym. Tu pojawia się pierwszy problem, bo słyszałem, że esp potrzebuje dość sporo energii do zasilania. Myślicie, że taki układ ma prawo działać przez dłuższy czas? A może zamiast esp powinienem spróbować czegoś innego? Z góry dzięki za wszystkie rady

Witam, Właśnie rusza projekt, który ma umożliwiać zdalne nauczanie zagadnień z mechatroniki i przetwarzania sygnałów. Idea jest taka, aby każdy uczeń/student miał w domu swoje własne stanowisko ze szkoły, sam rejestrował dane, a następnie, żeby nauczył się je przetwarzać w chmurze. Na chwilę obecną szukane są pomysły, np.: 1) użytkownik sam zbiera dane drganiowe z kilkudziesięciu cykli prania, a dostarczony generator dodaje sygnały powolnego uszkodzenia łożyska, generując zbiór Big Data. Następnie, użytkownik zgodnie z instrukcją opracowuje w chmurze algorytm Novelty Detection (np.sieć LSTM). 2) w zestawie jest obudowa łożyska, która jest elektromechanicznie wzbudzana z wykorzystaniem Arduino/Raspberry Pi. Drugi układ Arduino/Raspberry Pi rejestruje odpowiedź na wymuszenie. Następnie, estymowana funkcja odpowiedzi częstotliwościowej (FRF) jest wykorzystywana jako część stochastyczna sygnału syntetycznego rozwoju uszkodzenia łożyska tocznego. Na jej podstawie budowany jest zbiór Big Data, który bardzo wiernie odzwierciedla sygnały rzeczywiste. Dane są zbierane od wielu użytkowników i są użyte w procesie uczenia maszynowego w chmurze. 3) oczywiście, takie zestawy WYMUSZENIE/REJESTRACJA same w sobie pozwalają na analizę wpływu rodzaju wymuszenia na estymowaną FRF 4) Dalsze pomysły?! Pozdrawiam, Ajab00

Podczas ostatniej akcji kuponowo-rabatowej stałem się posiadaczem RaspberryPi 3B+. Od początku w planach miałem wykorzystanie tego mini komputerka jako serce konsoli retro. W pierwszej chwili chciałem stworzyć duży, stacjonarny automat Arcade. W porę doszedłem jednak do wniosku, iż nie mam za bardzo miejsca na taki "mebel". Dlatego też wizja się zmieniła. Postanowiłem zbudować przenośne urządzenie, podpinane do dowolnego Tv za pomocą kabla HDMI o długości 5m. Tak oto zrodziły się pierwsze plany. Zrobiłem jak zwykle przegląd rynku, sprawdziłem ceny poszczególnych elementów, analizowałem swoje możliwości wykonania obudowy. Ten etap trwał dość długo, ponieważ nie ukrywam, iż mam mało czasu na takie zabawy. Jednak w maju w końcu zabrałem się do budowy. Na początek musiała powstać przemyślana obudowa. Zdecydowałem się na zestaw przycisków i joystików z Aliexpress (nie spieszyło mi się, a za zaoszczędzone pieniądze można kupić coś dodatkowo). I tak oto w czerwcu stałem się posiadaczem zestawu jak poniżej: Oczywiście na tym etapie wybrałem już sposób rozmieszczenia przycisków i dokupiłem dodatkowo przyciski COIN oraz 1GRACZ i 2GRACZY (dolny rząd): Obudowa została wykonana ze starych paneli, narożniki wzmocnione kantówką 2x3cm i 2x2cm (wszystko z posiadanych ścinków). Rozplanowałem też umieszczenie wentylatora nawiewowego oraz kratki wentylacyjnej, co by zapewnić naszej konsoli dobre warunki pracy (wentylator z PC na 12V). Panele są różne, więc po wykonaniu pudła całość została przeciągnięta szpachlą samochodową z włóknami wzmacniającymi oraz przeszlifowana. Tak wykonana obudowa została oklejona folią carbon zakupioną na allegro. Skoro przyjąłem, że konsola będzie przenośna to trzeba było wzmocnić narożniki. Zrobiłem to z wykorzystaniem kątowników aluminiowych oraz narożników. Pozostało wykonanie połączeń elektrycznych. Przyciski są podświetlane, więc szkoda było tego nie wykorzystać. Stąd mamy po 4 przewody do każdego przycisku. Wykorzystałem posiadany zasilacz 5V 4A i zasiliłem z niego całość: poprzez przejściówki adapter gniazda 5.5/2.1-microUSB RaspPi, podświetlenie przycisków, wentylator. Na potrzeby wentylatora od PC dołożyłem małą przetwornicę StepUp ustawioną na 12V. Trzeba było rozplanować wyprowadzenie HDMI, USB i gniazdo zasilania z obudowy. W tym celu wyfrezowałem sobie płytkę z aluminium i umieściłem w niej takie oto przedłużki: Oczywiście serce naszej konsoli również znalazło się w środku wraz z oprogramowaniem RetroPie 4.5 i kartą SD 64GB zapełniona grami. Przy pierwszej konfiguracji korzystałem ze standardowej klawiatury PC ale w późniejszym etapie dla wygody wykorzystuję klawiaturę MT08 oraz dorywczo pad Tracer Recon PC. Nie opisuję procesu instalacji i konfiguracji RetroPie, ponieważ najlepiej w tym celu korzystać z internetu i strony projektu; https://retropie.org.uk/ Całość działa od kilku dni. Miałem sporo problemów z konfiguracją joysticków. Początkowo dobrze działały tylko w menu RetroPie a w grach osie i przyciski były pozamieniane. Poradziłem sobie z tym ręcznie edytując pliki konfiguracyjne i w nich dokonałem odpowiednich zmian. Dłuższe testy pokażą co należy zmienić. Już na wstępie planuję dodanie przycisku do zał/wył malinki: Do dopełnienia całości - od spodu znajduje się 6 gumowych nóżek, by nie rysować stołu/ławy itp. Wszystkie zdjęcia pochodzą z różnych etapów budowy i nie koniecznie odzwierciedlają w pełni gotowe urządzenie. Jednak już w takiej formie przechodziło wstępne testy. RaspPi jest podczepione do dolnej płyty. Wszystko w środku zamocowane by nic nie latało. Wentylator wraz z przeciwległą kratką zapewniają bardzo dobre chłodzenie wszystkich urządzeń. Na razie z niedogodności to w razie problemów z kartą sd trzeba rozkręcić dół (8 śrubek w narożnikach). Przydałaby się jakaś mała klapka rewizyjna, ale na razie nie mam pomysłu na jej wykonanie. Ostatecznie dodam chyba również oznaczenia na przyciskach.

Witam, jestem w trakcie robienia sterownika do akwarium na raspberry pi zero w i domoticz. Sterownik do celowo ma załączać pompę, grzałkę, odczytywać temperaturę itd... i załączać oświetlenie stopniowo rozjaśniajac i przyciemniając. Nie potrafię uruchomić sterowania pwm. Z załacz/wył. poradziłem sobie dopisujac komendy do pliku domoticz.sh np: /usr/bin/gpio export 17 out A co mam dopisać by wyjście gpio 13 było PWM? Kilka dni już błądzę po internecie i już nie wiem co mam zrobić...

Witam serdecznie! Chciałbym się podzielić stworzoną przez siebie graficzną aplikacją na Raspberry Pi 4 do podkręcania i wyświetlania informacji o systemie (wersja jądra, akutalna temperatura procesora, aktualne jego zużycie). DZIAŁA TYLKO NA RASPBERRY PI 4 Aplikacja nadal jest w rozwoju więc jeszcze nie jest idealna lecz wyżej wymienione funkcje spełnia https://github.com/Jack477/CommanderPi

Na początku jedna uwaga: ten cykl artykułów nie jest podręcznikiem Pythona ani nie rości sobie praw do bycia takim. Używam w przykładach Pythona jako najbardziej popularnego języka programowania na RPi - ale równie dobrze mógłbym użyć Perla, C++ czy nawet Basha, a cykl jest po prostu "boczną odnogą" napisanego wcześniej cyklu o protokole HTTP. Dlatego też wiele kwestii zostało pominiętych i użytkownik musi większość problemów rozwiązać we własnym zakresie (czyli najprawdopodobniej znaleźć właściwe rozwiązanie w innym artykule). Ale przejdźmy do rzeczy. W poprzednim odcinku dowiedzieliśmy się, jak uruchomić z poziomu serwera WWW skrypty pisane w dowolnym języku, i jak pozwolić im na komunikację z GPIO i magistralami SPI/I2C na przykładzie odczytu danych z czytnika RFID. Dzisiaj spróbujemy komunikacji w drugą stronę: z poziomu przeglądarki spróbujemy wysłać coś na magistralę. Ale najpierw trochę teorii. Z artykułu o protokole HTTP (jeśli ktoś go nie przeczytał, to teraz jest najwyższy czas) mogliśmy dowiedzieć się, jak jest zbudowany URL. Widzimy tam, że w najprostszej postaci URL wygląda tak: http://<host><ścieżka>[?<zapytanie>] Możemy się domyślać, że host informuje przeglądarkę (i serwer) z jakim serwerem i jaką stroną ma się połączyć, ścieżka wskazuje na plik który mamy z serwera odczytać (lub - w przypadku skryptu - serwer ma go wykonać i przekazać nam wyniki), ale czym jest to całe zapytanie? Otóż są to dodatkowe dane przekazywane od klienta (czyli w naszym przypadku przeglądarki) do skryptu. Jak uprzednio wspominałem, format zapytania jest dowolny i zależy praktycznie od tego co potrafi klient i serwer, ale w praktyce używa się pewnej ustalonej składni: nazwa=wartość z możliwością przekazania większej ilości parametrów, oddzielając je znakami '&', czyli coś w rodzaju: nazwa1=wartość1&nazwa2=wartość2&nazwa3=wartość3 Zarówno nazwa jak i wartość mają swoje ograniczenia - mogą zawierać wyłącznie drukowalne siedmiobitowe znaki ASCII bez spacji (czyli z zakresu od 0x21 do 0x7E włącznie) z wyłączeniem niektórych znaków zastrzeżonych (np. trudno by było zastosować nazwę zawierającą w sobie znak równości, czy też umieścić znak '&' wewnątrz wartości). Dlatego też opracowano pewien sposób kodowania (tzw. "urlencode"), pozwalający na przekazanie dowolnych danych. Sposób jest bardzo prosty: znak spacji zamieniamy na '+' znaki które nie kolidują ze składnią zapytania pozostawiamy bez zmian pozostałe znaki (oraz znak + występujący w wartości) zamieniamy na ciąg %XX, gdzie 'XX' to szesnastkowa reprezentacja znaku. Tak więc np. ciąg znaków 'ala+ma kota' zostanie zakodowany jako: ala%2Bma+kota Oczywiście nie ma żadnych innych ograniczeń (poza oczywistymi, wynikającymi z maksymalnej długości URL-a którą może przyjąć serwer oraz takim, że nazwa nie może mieć aerowej długości). W szczególności przesłanie kilku wartości (np. informacji o zaznaczonych kilku możliwościach wyboru) nie wymaga jakichś specjalnych zabiegów, po prostu wystarczy zapytanie w stylu: nazwa=wybór1&nazwa=wybór3&nazwa=wybór7 O, i tu słyszę głosy programistów PHP - jak to? Przecież aby przesłać kilka wartości nazwa musi kończyć się znakami '[]' wskazującymi na tablicę, a dopiero wtedy w tablicy $_GET w pozycji wskazywanej przez 'nazwa[]' znajdzie się nie pojedyncza wartość, a tablica wartości! Niestety - dotyczy to wyłącznie PHP i jest to zaszłość historyczna (pochodzi z czasów, gdy nikt z twórców PHP nie wpadł na to że można przesyłać więcej niż jedną wartość; w związku z tym trzeba było dorobić na szybko jakąś protezę - i to taką, która nie wysadzi w kosmos wszystkich dotychczas napisanych skryptów w tym języku). No - ale dość już teoretyzowania, przejdźmy do praktyki. Serwer mamy już skonfigurowany, spróbujmy na początek napisać prosty program, wpisujący otrzymane zapytanie do pliku/ Utwórzmy więc w katalogu html plik "napis.cgi" z następującą zawartością: #!/usr/bin/env python3 import cgitb, os print("Content-Type: text/plain; charset=UTF-8\n") cgitb.enable(format="text") napis=os.environ.get("QUERY_STRING") if not napis: print ("A gdzie zapytanie?") else: open("dane.txt","w").write(napis) print ("Zapisałem:", napis) Po zmianie uprawnień na 0755 i wpisaniu w przeglądarkę np: http://<ip_malinki>/napis.cgi?Hello powinna ukazać się odpowiedź "Zapisane: Hello", a w pliku html/dane.txt znajdzie się otrzymany napis Dobra - ale przecież wspominałem o jakichś nazwach, wartościach, urlencode... a tymczasem przy próbie wpisania: http://<ip_malinki>/napis.cgi?Cześć, świecie pokazuje się zakodowana treść zapytania, i taka też ląduje w pliku! Powód jest prosty: Python - w przeciwieństwie do PHP - nie ma żadnych superglobali ani innych automagicznych zaklęć będących częścią języka i zajmujących się dekodowaniem tego, co przysłał serwer. To tego służy biblioteka o nazwie - jak łatwo zgadnąć - cgi. Do pobierania i udostępniania w programie parametrów przesłanych do skryptu służy klasa FieldStorage. Zainteresowanych odsyłam do dokumentacji, nas będą interesować jedynie dwie metody: getlist(name) zwracająca listę wszystkich wartości związanych z daną nazwą oraz getfirst(name, default=None) zwracająca pierwszą napotkaną wartość związaną z daną nazwą lub wartość określoną przez parametr default (domyślnie None), jeśli dana nazwa nie wystąpiła w zapytaniu. Przeróbmy nieco nasz skrypt - niech napisem będzie wartość skojarzona z nazwą "tresc": #!/usr/bin/env python3 import cgitb, cgi print("Content-Type: text/plain; charset=UTF-8\n") cgitb.enable(format="text") form = cgi.FieldStorage() napis = form.getfirst("tresc", '').strip() if not napis: print ("A gdzie treść?") else: open("dane.txt","w").write(napis) print ("Zapisałem:", napis) Teraz wysłanie zapytania typu: http://<ip_malinki>/napis.cgi?tresc=Cześć, świecie spowoduje pojawienie się prawidłowej odpowiedzi oraz zapisanie prawidłowego tekstu do pliku. Ponieważ wpisywanie tego typu poleceń do pola adresu przeglądarki nie jest specjalnie wygodne, możemy zrobić prosty formularz, z którego dane będziemy przesyłać do naszego skryptu: #!/usr/bin/env python3 import cgitb, cgi, html print("Content-Type: text/html; charset=UTF-8\n") cgitb.enable(format="html") form = cgi.FieldStorage() napis = form.getfirst("tresc", '').strip() wynik="""<!DOCTYPE html> <html> <head> <title>Prosty formularz</title> </head> <body> %s <form method="post"> <input type="text" name="tresc" value="%s"> <input type="submit"> </form> </body> </html> """ if not napis: komunikat = "A gdzie treść?" else: open("dane.txt","w").write(napis) komunikat = "Zapisałem: "+ napis print(wynik % (html.escape(komunikat), html.escape(napis, True))) Teraz mamy już prawdziwy formularz. Spróbujmy więc przekazać dane do jakiegoś urządzenia podłączonego do naszej malinki. Jako przykład wybrałem popularny wyświetlacz tekstowy LCD 16x2 z interfejsem I2C. Połączenie jest w tym przypadku dużo prostsze, niż było to przy czytniku RFID. Interfejs I2C wymaga podłączenia tylko dwóch przewodów poza zasilaniem. Pamiętać należy, że wyświetlacz wymaga zasilania 5V! A więc układ połączeń jest taki: Pin 2 (+5V) do VCC wyświetlacza Pin 6 (GND) do GND wyświetlacza Pin 3 (SDA1) do SDA wyświetlacza pin 5 (SCL1) do SCL wyświetlacza Spróbujmy najpierw uruchomić wyświetlacz. Ciekawy artykuł na ten temat można znaleźć w serwisie Circuit Basics, ale dla niecierpliwych przygotowałem krótki sposób uruchomienia. Przede wszystkim potrzebny będzie moduł obsługi szyny I2C: sudo apt install python3-smbus Niestety - programu obsługi wyświetlacza w repozytorium nie ma. Na szczęście wspomniany artykuł pokazuje prosty, niewielki moduł który to umożliwia. Moduł wraz z programem demonstracyjnym można ściągnąć z githuba, na wszelki wypadek sam plik RPi_I2C_driver.py dodałem do załącznika. Plik ten należy umieścić w naszym katalogu html wraz z programem. Sprawdźmy najpierw, czy nasz wyświetlacz działa. Napiszemy krótki program (umieśćmy go przykładowo w pliku nasz_program.py): #!/usr/bin/env python3 import RPi_I2C_driver lcd=RPi_I2C_driver.lcd() lcd.lcd_clear() lcd.lcd_display_string_pos("Witaj swiecie!!!",1,0) Po uruchomieniu poleceniem: python3 nasz_program.py wyświetlacz powinien wyświetlić tekst "Witaj swiecie!!!". Co się jednak stanie, jeśli wyświetlacz nie będzie potrafił wyświetlić zadanego napisu? Przeróbmy nieco nasz program, aby można było podawać mu bezpośrednio napis: #!/usr/bin/env python3 import RPi_I2C_driver, sys lcd=RPi_I2C_driver.lcd() lcd.lcd_clear() napis = ' '.join(sys.argv[1:]) lcd.lcd_display_string_pos(napis,1,0) Jeśli teraz wywołamy go z parametrem: python3 nasz_program.py żółć zobaczymy na wyświetlaczu coś, co w żadnym przypadku z żółcią nie ma nic wspólnego... Jak to rozwiązać? Można oczywiście stworzyć własne znaczki i je wyświetlać w miejsce brakujących. Jest to jednak nieco żmudne, poza tym w języku polskim występuje 18 dodatkowych liter, a mamy do dyspozycji tylko 8 możliwości. Najprostszym rozwiązaniem będzie takie przekształcenie tekstu, aby mógł być bez problemu pokazany nawet na wyświetlaczach nie pozwalających na wprowadzanie dodatkowych znaków. Do tego posłuży nam moduł unidecode. Zaczynamy od instalacji, czyli: sudo apt install python3-unidecode Moduł zawiera jedną tylko interesującą nas funkcję unidecode, tak więc nasz program będzie teraz wyglądać następująco: #!/usr/bin/env python3 import RPi_I2C_driver, sys from unidecode import unidecode lcd=RPi_I2C_driver.lcd() lcd.lcd_clear() napis = unidecode(' '.join(sys.argv[1:])) lcd.lcd_display_string_pos(napis,1,0) Po uruchomieniu możemy zobaczyć, że program tym razem zamiast krzaków wyświetla po prostu literki pozbawione znaków diakrytycznych. Teraz możemy już przerobić nasz skrypt tak, aby wpisywane wartości zamiast do pliku wypisywane były na wyświetlaczu: #!/usr/bin/env python3 import cgitb, cgi, html, RPi_I2C_driver from unidecode import unidecode print("Content-Type: text/html; charset=UTF-8\n") cgitb.enable(format="html") form = cgi.FieldStorage() napis = form.getfirst("tresc", '').strip() wynik="""<!DOCTYPE html> <html> <head> <title>Prosty formularz</title> </head> <body> %s <form method="post"> <input type="text" name="tresc" value="%s"> <input type="submit"> </form> </body> </html> """ if not napis: komunikat = "A gdzie treść?" else: napis2 = unidecode(napis) lcd=RPi_I2C_driver.lcd() lcd.lcd_clear() lcd.lcd_display_string_pos(napis2,1,0) komunikat = "Wyświetlam: "+ napis2 print(wynik % (html.escape(komunikat), html.escape(napis, True))) Jak widać, nasz skrypt radzi sobie bez problemu nawet z takimi alfabetami jak chiński czy koreański! Tyle na dziś - następnym razem postaram się pokazać kilka przydatnych (szczególnie dla początkujących) dyrektyw konfiguracyjnych Apacza i spróbuję rozwiązać problem jednoczesnego dostępu do GPIO. W załączniku driver wyświetlacza: driver.tgz

Z poprzedniej części dowiedzieliśmy się, jak w prosty i wygodny sposób skonfigurować serwer Apache. Uruchomiliśmy nawet prosty program w PHP, który działa z uprawnieniami zwykłego użytkownika. Jednak PHP nie jest jedynym językiem, w którym możemy tworzyć skrypty. Już przed jego powstaniem opracowano znormalizowany interfejs CGI (czyli Common Gateway Interface), który umożliwiał pisanie programów wykonywanych przez serwer w dowolnym języku. PHP zyskał dużą popularność — szczególnie po ukazaniu się wersji 4 — przede wszystkim dlatego, że był zintegrowany z serwerem i interpreter rezydował w pamięci, podczas gdy wykonanie skryptu np. w Perlu wymagało za każdym razem załadowania interpretera, co trochę trwało. Jednak o ile na przełomie tysiącleci, w epoce dość wolnych dysków o niezbyt wielkiej pojemności było to bardzo ważne, dzisiaj traci to znaczenie - musimy pamiętać, że nasza malinka to demon prędkości w porównaniu z serwerami z lat 90-tych. Nawet programy w PHP są czasem z różnych przyczyn wykonywane jako CGI, a duże pojemności pamięci, szybkie dyski oraz (w przypadku niektórych języków) automatyczna kompilacja do kodu pośredniego pozwalają zmniejszyć ten czas do niezauważalnego minimum. Oprócz CGI powstały inne jeszcze metody komunikacji programów z serwerem, od zarzuconego już dawno SSI, poprzez interfejsy FastCGI, WSGI aż do tworzenia kompletnych serwerów w innych językach programowania i używania głównego serwera jedynie jako reverse proxy. My jednak zajmiemy się najprostszą metodą - czyli właśnie CGI. Interfejs jest bardzo prosty. W sumie wystarczy wiedzieć kilka rzeczy: w czasie wysyłania nagłówków wszystkie pojedyncze znaki '\n' są zamieniane na wymagane przez protokół HTTP pary '\r\n'; dodatkowy nagłówek Status zamieniany jest na linię odpowiedzi serwera i może być stosowany np. do przekazania kodu błędu lub po prostu innej odpowiedzi serwera niż domyślne (w przypadku jego braku) "200 OK"; nagłówki zapytania dostępne są w postaci zmiennych środowiskowych. Program po prostu musi wypisać na wyjście wszystkie potrzebne nagłówki wraz z kończącą je pustą linią, a dopiero wtedy wypisać właściwą odpowiedź (np. kod HTML). Z podobnym zachowaniem spotkaliśmy się zresztą już wcześniej przy tworzeniu serwerów HTTP na Arduino czy ESP, więc nie powinno to sprawiać trudności. Niestety, serwery nie są domyślnie skonfigurowane do obsługi CGI. Na szczęście w przypadku Raspbiana konfiguracja jest bardzo prosta. Zaczniemy od tego, że moduł odpowiedzialny za obsługę CGI co prawda został dostarczony razem z serwerem, ale nie jest domyślnie włączony. Musimy więc go włączyć poleceniem: sudo a2enmod cgi Co prawda dostaniemy informację o konieczności restartu serwera, ale na razie nie musimy tego robić bo i tak będziemy dopisywać obsługę CGI do naszej donyślnej strony. W tym celu otwieramy w edytorze plik konfiguracyjny, np. przez: sudo nano /etc/apache2/sites-available/000-default.conf i dopisujemy dosłownie dwie linijki do części Directory. Linijka AddHandler informuje serwer, że pliki o rozszerzeniu .cgi mają być traktowane jak skrypty, a Options zezwala na wykonywanie skryptów w ogóle w danym katalogu: AddHandler cgi-script .cgi Options ExecCGI Tak więc konfiguracja będzie wyglądać następująco: Po restarcie serwera możemy już spróbować napisać pierwszy skrypt. Musi mieć on rozszerzenie .cgi i mieć prawo do wykonywania. A więc do dzieła! Napiszmy pierwszy program, robiący dokładnie to samo co poprzedni skrypt w PHP. Ponieważ najbardziej popularnym językiem stosowanym na RPi jest python, będziemy pisać skrypty właśnie w tym języku. Umieśćmy więc w katalogu html plik test.cgi z następującą zawartością: #!/usr/bin/env python3 print("Content-Type: text/plain; charset=UTF-8\n") try: open("pytest.txt","w").write("Cos tam\n") print("Zapisane") except: print("Nie da się zapisać") Ponieważ funkcja print dodaje nową linię na końcu, znaczek '\n' w nagłówku wymusza po prostu pustą linię za jedynym interesującym nagłówkiem Content-Type. Teraz musimy nadać plikowi prawa do wykonania: chmod 755 html/test.cgi i po skierowaniu przeglądarki na adres http://<ip_malinki>/test.cgi powinniśmy zobaczyć wynik "Zapisane" lub informację, że zapisać się nie dało z jakichś przyczyn (z jakich — o tym później). Jako że najprawdopodobniej bardziej nas będą interesować zastosowania serwera w IoT czy robotyce — spróbujmy zaprząc Apacza do jakichś bliższych sercu zadań. Ostatnio ktoś pytał o możliwość odczytu kart RFID i pokazywania tego w przeglądarce... spróbujmy! Użyjemy do tego popularnego czytnika RC522, do którego biblioteki są dostępne bez zbytniego szukania. Zacznijmy od tego, że musimy zainstalować podstawowe biblioteki do Pythona, które umożliwią nam operowanie GPIO oraz magistralą SPI. A więc: sudo apt install python3-rpi.gpio python3-smbus python3-pip Biblioteka RPi.GPIO zapewne jest większości znana, smbus pozwala na komunikację właśnie z magistralą SPI, a pip pozwala na instalację pakietów, których nie ma w repozytorium Raspbiana. Upewnijmy się jeszcze, czy mamy włączoną obsługę SPI (w raspi-config), oraz czy użytkownik pi (lub ten, na którego się logujemy) ma dostęp do wszystkiego co potrzebne bez używania sudo. A więc wydajemy polecenie: groups Powinno wyświetlić się kilkanaście grup, do których należy użytkownik pi, czyli coś w rodzaju: pi adm dialout cdrom sudo audio video plugdev games users input netdev bluetooth gpio i2c spi Nas interesują tylko trzy ostatnie. Jeśli któraś nie występuje, musimy ją dopisać: sudo usermod -a -G spi,i2c,gpio pi (oczywiście wpisujemy tylko brakujące) i po przelogowaniu powinniśmy już widzieć użytkownika pi dopisanego do właściwych grup, umożliwiających manipulację pinami GPIO oraz magistralami SPI i I2C. Niestety, biblioteki obsługi RC522 w repozytorium nie ma, ale możemy ją zainstalować używając polecenia pip3: sudo pip3 install mfrc522 Kolej na podłączenie czytnika do naszej malinki. Podłączamy tylko siedem z ośmiu pinów, bo nie używamy pinu IRQ, a więc: SDA do pinu 24 SCK do pinu 23 MOSI do pinu 19 MISO do pinu 21 GND do pinu 6 RST do pinu 22 3.3v do pinu 1 Po włączeniu malinki (pamiętajmy, że wszelkie połączenia musimy wykonywać z odłączonym zasilaniem) powinna zapalić się dioda na czytniku. Napiszmy więc prosty program, umożliwiający odczyt kart: #!/usr/bin/env python3 import RPi.GPIO as GPIO from mfrc522 import SimpleMFRC522 reader = SimpleMFRC522() try: id=reader.read_id_no_block() finally: GPIO.cleanup() print("ID=%s" % id) Użyjemy tu nieblokującej metody, gdyż w przypadku skrypty CGI nie możemy blokować połączenia — przeglądarka przerwie połączenie, jeśli nie doczeka się danych w określonym czasie. Po uruchomieniu programu (bez sudo oczywiście) powinniśmy móc odczytać numerek zbliżonej karty lub pusty napis, jeśli karty nie ma. Czyżby to było takie proste? Spróbujmy teraz przerobić nasz program na skrypt CGI. Wystarczy do tego dopisać linijki odpowiadające za wysłanie nagłówków, i powinno działać! Tworzymy więc w katalogu html plik o nazwie (przykładowo) czytnik.cgi i wpisujemy do niego: #!/usr/bin/env python3 import RPi.GPIO as GPIO from mfrc522 import SimpleMFRC522 print("Content-Type: text/plain; charset=UTF-8\n") reader = SimpleMFRC522() try: id=reader.read_id_no_block() or '' finally: GPIO.cleanup() print("ID=%s" % id) Nadajemy plikowi prawa do wykonywania: chmod 755 html/czytnik.cgi Na wszelki wypadek sprawdźmy, czy działa wydając po prostu polecenie: html/czytnik.cgi Powinno działać! A więc przeglądarka w ruch, wpisujemy adres http://<ip_malinki>/czytnik.cgi i... ...i nic. Zaglądając do logu błędów Apacza zobaczymy, że program nie został wykonany. Dlaczego? Ponieważ ciągłe zaglądanie do logów nie jest zbyt wygodne, zmuśmy nasz skrypt do reakcji na błędy i wyświetlania ich w przeglądarce. Użyjemy do tego modułu cgitb, który pozwala właśnie na takie manipulacje. A więc nowa wersja skryptu będzie wyglądać tak: #!/usr/bin/env python3 import RPi.GPIO as GPIO from mfrc522 import SimpleMFRC522 import cgitb print("Content-Type: text/plain; charset=UTF-8\n") cgitb.enable(format="text") # włączamy wyświetlanie błędów w formacie tekstowym reader = SimpleMFRC522() try: id=reader.read_id_no_block() or '' finally: GPIO.cleanup() print("ID=%s" % id) Po uruchomieniu możemy zobaczyć, że skrypt nie ma uprawnień do smbusa i gpio! Ale przecież użyliśmy wcześniej modułu ruid2, który powinien uruchomić nasz program jako użytkownik pi! Ki diabeł? Musimy to sprawdzić. Dodajmy do skryptu linijki, które pokażą nam z jakimi uprawnieniami wykonywany jest nasz program: #!/usr/bin/env python3 import RPi.GPIO as GPIO from mfrc522 import SimpleMFRC522 import cgitb, sys, os print("Content-Type: text/plain; charset=UTF-8\n") sys.stdout.flush() # aby upewnić się, że nagłówki nie zostaną zbuforowane os.system("groups") Po uruchomieniu widzimy, że program uruchomił się z uprawnieniami grupy pi, ewentualnie (zależnie od konfiguracji) dodatkowo www-data. A gdzie nasze gpio? Gdzie spi? Spójrzmy do konfiguracji modułu ruid2. O właśnie — kazaliśmy uruchomić program z uprawnieniami użytkownika pi i grupy pi, bez żadnych dodatkowych grup. Ale od czego jest linijka RGroups? Właśnie od tego, aby dopisać dodatkowe grupy! Poprzednio mieliśmy tam wpisane @none. Dopiszmy więc dodatkowe grupy, zmieniając tę linijkę na: RGroups gpio spi i2c i zrestartujmy Apacza. Powinno być dobrze... Ale nie jest. Przeglądarka uparcie pokazuje nam, że Apacz nic nie wie o żadnych dodatkowych grupach... dlaczego? Po prostu zadziałało zabezpieczenie. Moduł nie pozwala nam na uruchamianie programu z uprawnieniami grup systemowych, czyli w przypadku Raspbiana z numerkami grupy mniejszymi niż 1000. Na szczęście i na to jest sposób. W konfiguracji możemy podać nazwę grupy o najmniejszym ID, który jest dozwolony. Musimy w tym celu przejrzeć plik grup: cat /etc/groups lub lepiej, aby ograniczyć wyświetlanie do najbardziej istotnych rzeczy: egrep '(spi|i2c|gpio)' /etc/group i znaleźć, która z tych grup ma najniższy numerek. W moim przypadku jest to grupa gpio o numerze 997, a więc dopisujemy dodatkową linię do konfiguracji ruid2: RMinUidGid pi gpio W efekcie nasza konfiguracja wygląda tak: Teraz restartujemy Apacza — i w efekcie po przyłożeniu karty do czytnika i wczytaniu strony do przeglądarki zobaczymy wreszcie odczytany ID! Ponieważ chcielibyśmy, aby dane były pokazywane na bieżąco, możemy po prostu dopisać odpowiedni nagłówek wymuszający na przeglądarce odświeżenie strony. Tak więc po usunięciu niepotrzebnych już linii i delikatnym "upiększeniu" nasz kod będzie wyglądać tak: #!/usr/bin/env python3 import RPi.GPIO as GPIO from mfrc522 import SimpleMFRC522 import cgitb print("Content-Type: text/plain; charset=UTF-8\nRefresh: 5\n") cgitb.enable(format="text") reader = SimpleMFRC522() try: id=reader.read_id_no_block() or 'Brak karty' finally: GPIO.cleanup() print("ID=%s" % id) Prawda, jakie to proste? Tyle na dziś — w następnej części dowiemy się, jak w pythonowym skrypcie CGI możemy dobrać się do przesyłanych danych.

Stacja meteorologiczna służy do przeprowadza dokładnych pomiarów pogody oraz sprawdzania jakości powietrza. Urządzenie pobiera dane z czujników, następnie zapisuje je do bazy danych po czym zostają wyświetlone na stronie internetowej. Całe urządzenie zostało zamknięte w obudowie wydrukowanej w drukarce 3D. Czujniki zainstalowane w urządzeniu pobierają dokładne dane pogodowe. Stacja posiada zaawansowaną metodę pomiaru prędkości wiatru przy użyciu ultradźwiękowych czujników ruchu. Stacja działa na Raspberry PI 3+, obsługuje również starsze modele (z wbudowanym wifi) oraz na Raspberry PI ZERO (W). System operacyjny to Linux wersja Raspbian STRETCH LITE bez interfejsu graficznego. Kod źródłowy czujników został napisany w Python’ie. Dane z czujników zapisywane są przy użyciu Raspberry PI do bazy danych MySQL. Następnie zostają wyświetlone w aplikacji internetowej, która napisana została w PHP. Urządzenie wymaga połączenia z Internetem. Aktualnie wykorzystywane jest połączenie poprzez WIFI. Komunikacja pomiędzy urządzeniem a administratorem przeprowadzana jest poprzez protokół SSH i FTP. Stacja jest zbudowana w taki sposób, żeby użytkownik mógł w łatwy sposób ją obsługiwać. Aby włączyć stację należy podłączyć ją do prądu. Działanie urządzenia zostanie zasygnalizowane świeceniem diody (czerwonej) oraz miganiem diody zielonej, która świeci przy wysyłaniu danych do bazy. Oprócz graficznego przedstawienia danych aplikacja posiada skrypty do obliczenia m. in. wschodu i zachodu słońca w danej lokalizacji. Oprogramowania posiada opcje, w których m. in. możemy ustawić czas pomiaru pogody i zapisu do bazy danych. Jest to ważne ponieważ możemy sami ustalać jak często stacja ma sprawdzać stan pogody Projekt obudowy Obudowa została zaprojektowana w programie FreeCAD. Składa się ona z 9 elementów. Została wydrukowana w drukarce 3D – Anet A8 (moja własna drukarka). Materiał wykorzystany podczas druku to PLA, temperatura druku 205°C. Łączny czas druku wynosi 19 godzin, zużywa 174 gram materiału przy wysokości warstwy 0.2mm. Projekt obudowy został wykonany w taki sposób, aby urządzenie było odporne na deszcz i wiatr. Opływowość stacji pozwala na wykonywania dokładnych pomiarów prędkości wiatru. Na samej górze stacji zamontowany został czujnik opadów deszczu oraz czujnik natężenia światła. Następnie pod nimi umieszczone są ultradźwiękowe czujniki prędkości wiatru. Kolejny element to obudowa chroniąca RB PI i elektronikę. Obudowa posiada specjalne mocowanie na RP PI, które sztywno trzyma urządzenie. Następnym elementem jest rdzeń, do którego przymocowane są pozostałe czujniki. Obudowę zamyka podstawka, w której znajduję się główny przewód zasilający oraz diody sygnalizujące działanie. Czujniki Urządzenie w czasie rzeczywistym pobiera dane z 7 czujników, następnie są one w odpowiedni sposób przekazywane do modułu detektorów i mikrokontrolerów, które zwracają dane do Raspberry PI. Lista czujników: Czujnik opadów Czujnik pomiaru opadów atmosferycznych składa się z dwóch części: sondy pomiarowej „YL-83” oraz modułu detektora „LM393”, który posiada wyjście analogowe umożliwiające pomiar deszczu. Moduł zasilany jest napięciem 5V. Czujnik natężenia światła Czujnik światła bazuje na fotorezystorze „GL5537-1”. Jest to opornik fotoelektryczny, który zmienia swoją rezystancję pod wpływem padającego światła. Prędkość wiatru Pomiar prędkości wiatru bazuje na ultradźwiękowym czujniku odległości „HC-SR04”. Ultradźwiękowy pomiar prędkości polega na zmierzeniu różnicy czasu przejścia impulsów ultradźwiękowych propagujących w kierunku przeciwnym do kierunku przepływu. Temperatura i wilgotność Do wykonywania pomiaru temperatury i wilgotności powietrza został wykorzystany popularny moduł „DHT11”. Moduł składa się z czujnika oraz niezbędnego do poprawnego działania układu: rezystora i kondensatora filtrującego napięcie zasilania. Ciśnienie Moduł z cyfrowym barometrem „BMP180” wykonuje pomiar ciśnienia w zakresie od 200hPa do 1100hPa. Układ komunikuje się przy użyciu interfejsu IC2, co zapewnia wysoką dokładność i stabilność wykonywanych pomiarów. Jakoś powietrza Moduł jakości powietrza „MQ-135” wykrywa w atmosferze: benzen, amoniak (NH3) oraz dwutlenek węgla (CO2). Inne: Przetwornik A/C i C/A 8-bitowy I2C Głównym układem przetwarzania danych w tej pracy jest przetwornik PCF8591. Moduł posiada czterokanałowy przetwornik analogowo-cyfrowy działający w oparciu o 8-bitowy systemem akwizycji danych. Komunikacja opiera się na szeregowej wysyłce danych za pomocą dwukierunkowej magistrali I2C.

Witam wszystkich, chciałbym zrobić listę obecności za pomocą legitymacji uczniowskich. Cały proces ma się odbywać w przeglądarce, tak więc zainstalowałem serwer na raspberry napisałem stronę która służy do stworzenia bazy danych tj imie nazwisko i numer legitymacji. Jednakże numer legitymacji musze odczytać za pomocą czytnika RFID program w pythonie napisałem i w terminalu działa prawidłowo. Problem pojawia się kiedy próbuje go uruchomić przez php takim oto skryptem: <?php $card = shell_exec('sudo python3 /var/www/.../Read.py'); echo $card; > w zmiennej $card zapisany jest numer legitymacji oczytany przez czytnik, ale nie jest on wyświetlany w oknie przeglądarki. Jakieś pomysły sugestie?

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

Serwer WWW jest jednym z podstawowych programów używanych na Raspberry Pi. Ponieważ instalacja serwera jest dokładnie omówiona w kursie, a i pierwsze spotkanie z Apache najprawdopodobniej mamy już za sobą - nie będę opisywać podstaw, a przejdę od razu do trochę (naprawdę tylko trochę) bardziej zaawansowanej konfiguracji, ułatwiającej nam pracę i zabawę z serwerem. Pierwszą przykrą rzeczą, na którą się na pewno natkniemy będzie fakt, że nie mamy dostępu do katalogu /var/www/html, gdzie znajdują się pliki strony serwowanej przez Apacza. Większość radzi sobie z tym w ten sposób, że po prostu zmienia właściciela owego katalogu na użytkownika, na którego się loguje i teoretycznie wszystko działa... Niestety, tylko teoretycznie. Operowanie jakimiś danymi poza własnym katalogiem domowym jest niewygodne, a czasami (np. w przypadku ftp/sftp i ustawionego chroota) wręcz niemożliwe. W dodatku istnieje niebezpieczeństwo, że przy jakimś upgradzie system po prostu nadpisze zawartość tego katalogu i nasza strona będzie istniała tylko w przepastnych czeluściach /dev/null... Tymczasem Apache jest chyba najbardziej konfigurowalnym programem na naszej malince, i najprostszym sposobem będzie umieszczenie katalogu ze stroną w naszym katalogu domowym (czyli np. /home/pi/). Apache potrafi serwować różne zawartości z różnych katalogów poprzez mechanizm tzw. hostów wirtualnych, ale jako że konfiguracja tego jest na tyle obszerna, że zasługuje co najmniej na jeden oddzielny artykuł - na razie interesuje nas wyłącznie konfiguracja domyślnego katalogu. Zacznijmy od utworzenia katalogu ze stroną i umieszczeniu tam jakiegoś najprostszego testowego pliku: mkdir ~/html echo "To tylko test" > ~/html/index.html Następnie musimy poprawić konfigurację domyślnej strony serwera. W tym celu otwieramy w edytorze plik konfiguracyjny: sudo nano /etc/apache2/sites-enabled/000-default.conf Znajduje się tam linijka: DocumentRoot /var/www/html informująca serwer o położeniu domyślnej strony. Musimy zmienić ją na: DocumentRoot /home/pi/html Ale to jeszcze nie wszystko. Należy również poinformować serwer, co może z tym katalogiem robić. Pod tą linijką dopisujemy więc: <Directory /home/pi/html> AllowOverride all Require all granted </Directory> Dyrektywa AllowOverride pozwala na późniejsze dokonfigurowywanie poprzez plik .htaccess, Require otwiera nielimitowany dostęp do strony. Fragment pliku odpowiedzialny za naszą konfigurację powinien wyglądać więc tak: Teraz możemy zrestartować Apacza: sudo systemctl restart apache2 lub po prostu kazać mu jeszcze raz wczytać konfigurację: sudo apachectl graceful Po prawidłowym przeprowadzeniu wszystkich operacji powinniśmy po wpisaniu do przeglądarki adresu malinki ujrzeć na ekranie napis "To tylko test". Sytuację z położeniem katalogu ze stroną mamy więc już naprawioną - ale za chwilę natkniemy się na następną, niemniej przykrą rzecz: otóż Apacz mimo że już wie o tym, że pliki ze stroną są w naszym katalogu domowym - wciąż działa z uprawnieniami użytkownika www-data. To może doprowadzić do absurdalnej sytuacji, kiedy w naszym katalogu domowym znajdują się pliki i subkatalogi nie będące naszą własnością, z którymi nie bardzo możemy cokolwiek zrobić (np. pliki upload WordPressa). Stwórzmy więc testowy plik html/test.php: <?php if (file_put_contents('test.txt','To jest test php')) { echo "Zapisane"; } else { echo "Nie dało się zapisać"; } ?> Po wpisaniu w przeglądarkę adresu http://ip_malinki/test.php zobaczymy niestety napis "Nie dało się zapisać", a w logu błędów (czyli /var/log/apache2/error.log) komunikat podobny do tego: PHP Warning: file_put_contents(test.txt): failed to open stream: Permission denied in /home/pi/html/test.php on line 2 Widzimy, że nasz wielce ambitny program nie ma uprawnień do zapisu Ale i na to jest sposób: musimy przekonać Apacza, aby naszą stronę serwował jako użytkownik pi a nie www-data! W tym celu instalujemy moduł ruid2, odpowiedzialny za zmianę "w locie" uprawnień: sudo apt install libapache2-mod-ruid2 -y Po instalacji moduł zostanie włączony w Apaczu, pozostanie nam więc tylko dodanie linijek odpowiedzialnych za zmianę użytkownika. W tym celu znów otwieramy w edytorze plik 000-default.conf i przed sekcją <Directory> dopisujemy: <IfModule mod_ruid2.c> RMode config RUidGid pi pi RGroups @none </IfModule> (co oznacza, że ręcznie podajemy dane, serwer ma działać z uprawnieniami użytkownika pi.pi bez żadnych dodatkowych grup). Po restarcie lub reloadzie serwera, jeśli nic się nie będzie działo, możemy spróbować czy nasze działania przyniosły spodziewany efekt. Jeśli teraz skierujemy przeglądarkę na adres ip_malinki/test.php - powinniśmy zobaczyć napis 'Zapisane'. Po wydaniu polecenia ls -l zobaczymy, że plik test.txt został utworzony z właściwymi uprawnieniami, czyli coś w rodzaju: $ ls -l html razem 12 -rw-r--r-- 1 pi pi 5 kwi 22 06:11 index.html -rw-r--r-- 1 pi pi 84 kwi 22 10:30 test.php -rw-r--r-- 1 pi pi 15 kwi 22 10:35 test.txt Tyle na dziś - w następnej części zobaczymy, jak można uruchamiać poprzez serwer programy w Pythonie (w rzeczywistości w dowolnym języku programowania) oraz w jaki sposób udostępnić tym programom GPIO czy też magistrale SPI oraz I2C.

Cześć, jestem czytelnikiem Forbota od dłuższego czasu interesuje się elektroniką ale tylko hobbystycznie przez co mam wiedzę znikomą w wielu tematach - proszę o wyrozumiałość Robiłem kilka przymiarek to automatyki domowej zanim odkryłem że są „gotowe” rozwiązania takie jak: Supla, HomeAssistant, OpenHab, Domoticz i inne. Szukałem porównania, możliwości skalowalność i nie znalazłem odpowiedzi na pytanie który system by sprostał tematowi jaki mam, a jest ono dość proste: - Arduino (kilka sztuk) - komunikacja z Arduino tylko LAN (moduł Ethernet lub Serial + moduł Wifi) - Arduino jako klient, przekażniki czujniki sterowane przewodowo przez Arduino - serwerze własny z Linuxem (offline !) jak Domoticz, OpenHab itp. Teraz mam „zrobiony” od podstaw taki system bardzo prosty i działa dobrze ale ciągle rozbudowuje go o kolejne dodatki i tak się zastanawiam - jak było wiele razy powtarzane żeby nie wyważać otwartych drzwi - lepiej pomóc już działającej społeczności niż samemu ją tworzyć od nowa. Nie oczekuje gotowego rozwiązania tylko wskazania drogi którą pójść czy rozwijać swój projekt? czy jest rozwiąznie które wyżej wymienione wymagania ogarnie? Z Domoticzem przez chwilę było dobrze ale nie po kablu. Jeżeli będzie zainteresowanie tematem mogę rozpisać co teraz zostało zrobione i jak to działa teraz, może mam dobry pomysł tylko go trzeba opakować sensowniej i nie pakować się w gotowe (ogromne programowo) rozwiązania. Dziękuję za przeczytanie.

Mam problem z VNC a natomiast od VNC dostaje komunikat "Cannot currlently show the desktop"

Witam! Mam problem z kompilacją OBS'a na raspberry pi3b+. Robie dokładnie to co w tym poradniku: https://obsproject.com/forum/threads/obs-raspberry-pi-build-instructions.115739/#post-437594 I podczas kompilacji malinka zacina się na dobre. Czy da się coś z tym zrobić? Może jest jakiś inny program do streamowania na YT który działałby na raspberry?

Stacja pogodowa z użyciem czujnika BME680 Stacja pogodowa to jeden z najpopularniejszych projektów IoT, którym fani elektroniki zaczynają swoją przygodę z Raspberry Pi, sensorami, przesyłaniem danych oraz ich wizualizacją. W tym artykule przyjrzymy się monitorowaniu temperatury, wilgotności, ciśnienia barometrycznego i jakości powietrza za pomocą uniwersalnego czujnika, który łączy się bezpośrednio z Raspberry Pi bez dodatkowych komponentów. Dużym plusem tej aplikacji jest to, że nie wymaga ona dużego doświadczenia w elektronice i programowaniu a wprowadza wiele przydatnych zagadnień. W tym projekcie dodatkowo wdrożymy bazę danych do przechowywania odczytów wraz z interfejsem graficznym Grafana, aby zobaczyć aktualne odczyty. W aplikacji używam adresu IP: 192.168.12.16, który oznacza adres mojego Raspberry Pi. Do poprawnego działania na malince czytelnika, należy go zmienić w plikach źródłowych oraz przy konfiguracji Grafany. 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. Podłączenie BME680 do Raspberry Pi Pierwszym krokiem do uruchomienia aplikacji jest podłączenie czujnika do naszej Raspberry Pi. W zależności od producenta płytki, możemy komunikować się przez protokół SPI lub I2C. W tej aplikacji została wykorzystana płytka z pimoroni.com, która wspiera tylko protokół I2C. Czujnik jest połączony z Raspberry Pi przy użyciu czterech przewodów: Raspberry | BME680 ---------------------------------- 3V3 | 2-6V SDA1 I2C | SCA SCL1 I2C | SCL Ground | GND Specyficzną cechą tej płytki jest to, że została specjalnie zaprojektowana do wykorzystania wraz z magistralą I/O Raspberry Pi. Czujnik możemy podłączyć bez dodatkowych przewodów. Rys. 1. Bezpośrednie połączenie czujnika Jedyną wadą tego układu jest fakt, że czujnik zbiera pomiary blisko SoC-a co zmienia wskazania temperatury i wilgotności. Lepszym rozwiązaniem jest przedłużenie płytki przewodami i ustawienie sensora w bardziej przystępnym miejscu. Rys. 2. Połączenie przy użyciu przewodów Konfiguracja I2C na Raspberry Pi Przed uruchomieniem programów i instalacją potrzebnych narzędzi, musimy sprawdzić ustawienia konfiguracyjne portu I2C. Konfigurację przeprowadzamy przez wybranie z menu konfiguracyjnego lub przez komendę raspi-config: Rys. 3. Wybór z menu konfiguracyjnego Przechodzimy w Interfacing Options i wybieramy I2C: Rys. 4. Wybór interfejsu I potwierdzamy włączenie interfejsu naciskając Enter na opcji Yes: Rys. 5. Zatwierdzenie włączenia interfejsu I2C Poprawność połączenia należy sprawdzić w terminalu przy użyciu komendy: $>: sudo i2cdetect -y 1 W odpowiedzi otrzymamy tabelę adresów interfejsu I2C. Widoczny numer 76 oznacza, że czujnik został połączony i wykryty z adresem 0x76. Po tym zabiegu sprzętowa konfiguracja dobiegła końca i możemy zająć się potrzebnym oprogramowaniem. 0 1 2 3 4 5 6 7 8 9 a b c d e f 00: -- -- -- -- -- -- -- -- -- -- -- -- -- 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 70: -- -- -- -- -- -- 76 -- Pliki źródłowe Producent czujnika BME680 udostępnia przygotowane API na githubie. Na podstawie dokumentacji został stworzony kontroler obsługujący połączenie między Raspberry Pi a czujnikiem. Wysyłanie danych z pomiarów do brokera MQTT zostało zaimplementowane w języku C przy użyciu biblioteki paho.mqtt. Całości została połączona w pliku main.c. Dla wygody użytkownika został stworzony plik makefile do szybkiej kompilacji. Przed zbudowaniem aplikacji musimy dodać biblioteki służące do wysyłania danych do brokera MQTT. W repozytorium z plikami źródłowymi znajduje się także plik forwarder.py który został napisany do komunikacji między brokerem a bazą danych. Instalacja MQTT Protokół MQTT zapewnia lekką metodę przesyłania komunikatów przy użyciu modelu publikowania i subskrypcji. Dzięki temu nadaje się do transmisji wiadomości z urządzeń takich jak czujniki o niskiej mocy lub urządzenia mobilne jak smartfon lub mikrokontroler. Do zbudowania projektu wraz z klientem protokołu MQTT musimy pobrać bibliotekę z git-a i ją zainstalować. W tym celu wykonujemy sześć komend w terminalu: $>: git clone https://github.com/eclipse/paho.mqtt.c.git $>: cd paho.mqtt.c $>: git checkout v1.3.1 $>: cmake -Bbuild -H. -DPAHO_WITH_SSL=ON -DPAHO_ENABLE_TESTING=OFF $>: sudo cmake --build build/ --target install $>: sudo ldconfig Po zakończonej instalacji bibliotek możemy zająć się brokerem MQTT. Broker działa jak serwer, który otrzymuje dane na dany temat z różnych urządzeń. Klienci mogą subskrybować dane tematy oraz publikować wiadomości w różnych tematach. Instalacja dystrybucji Eclipse Mosquitto odbywa się przez wykonanie polecenia: $>: sudo apt install mosquitto mosquitto-clients Teraz mamy gotowe całe środowisko i możemy przystąpić do pierwszego uruchomienia aplikacji. W pierwszej kolejności otwieramy nowa konsolę i uruchamiamy broker MQTT za pomocą instrukcji: $>: mosquitto -v Gdy broker nasłuchuje w tle, możemy uruchomić aplikację stacji pogodowej. W innym terminalu, w katalogu application wykonujemy komendę: $>: make Następnie uruchamiamy aplikację WeatherStation: $>: ./WeatherStation 5 1000 logs.txt Argumenty w tej komendzie oznaczają: Pierwsza liczba oznacza przerwę między kolejnymi pomiarami w sekundach, Druga liczba oznacza ilość pomiarów, Trzeci argument to nazwa pliku z logami. Instalacja i konfiguracja InfluxDB W naszym przykładzie używamy InfluxDB do przechowywania danych, ponieważ są one zoptymalizowane pod kątem danych szeregów czasowych. Oczywiście możliwa byłaby również praca z innymi bazami danych, takimi jak MariaDB lub mongoDB, ale InfluxDB działa bezpośrednio z Grafaną. Pierwszą rzeczą do zrobienia jest instalacja InfluxDB na Raspberry Pi. Instalacja jest dość łatwa, wystarczy wykonać dwa następujące polecenia w terminalu: $>: sudo apt install influxdb $>: sudo apt install influxdb-client Po udanej instalacji uruchamiamy InfluxDB i kontrolujemy bieżący status za pomocą następujących poleceń: $>: sudo service influxdb start $>: sudo service influxdb status Obecny status InfluxDB powinien być aktywny: Rys. 6. Status aplikacji InfluxDB Po instalacji InfluxDB musimy wprowadzić jedną zmianę w konfiguracji, aby włączyć punkt końcowy HTTP. Jest to konieczne, ponieważ chcemy zapisać dane od subskrybenta MQTT do istniejącej bazy danych. Aby zmienić konfigurację, użyjemy następującej instrukcji: $>: sudo nano /etc/influxdb/influxdb.conf W pliku konfiguracyjnym przewijamy w dół za pomocą klawisza strzałki na klawiaturze do części [http] konfiguracji. Usuwamy zaznaczenie pierwszego ustawienia, usuwając znak "#" w trzech liniach, tak jak na poniższym rysunku. Klikamy "Ctrl+O", zatwierdzamy zmiany a następnie klikamy "Ctrl+X", aby wyjść z edytora tekstu nano. Rys. 7. Zmiany w pliku konfiguracyjnym InfluxDB Po każdej zmianie konfiguracji InfluxDB musi zostać ponownie uruchomiony, aby zmiany w konfiguracji były aktywne. Uruchomimy ponownie InfluxDB za pomocą następującego polecenia. $>: sudo service influxdb restart Konfiguracja jest zakończona i możemy przejść do stworzenia bazy danych, w której przechowywane są wszystkie pomiary oraz użytkownik, który zapisuje dane MQTT do bazy danych. Najpierw uruchomimy InfluxDB za pomocą następującego polecenia w terminalu Raspberry Pi: $>: influx Teraz stworzymy nową bazę danych o dowolnej nazwie. Jako nazwę wybieram „weather_stations”. Zbudujemy bazę danych poleceniem: > CREATE DATABASE weather_stations Baza danych została utworzona, a teraz tworzymy nowego użytkownika i dajemy mu prawo dostępu do utworzonej wcześniej bazy danych. Wybieram mqtt jako nazwę użytkownika i hasło. > CREATE USER mqtt WITH PASSWORD 'mqtt' > GRANT ALL ON weather_stations TO mqtt InfluxDB został zainstalowany i skonfigurowany. Stworzyliśmy bazę danych i użytkownika. Następnym krokiem jest upewnienie się, że baza danych jest wypełniona komunikatami MQTT. Przesyłanie pomiarów do bazy danych Teraz, gdy influxdb działa, musimy napisać mały skrypt, który przekazuje dane z brokera do InfluxDB. Do tego zadania został wykorzystany python, która przy użyciu biblioteki paho mqtt, zapisuje pomiary przychodzące do brokera w bazie danych. Plik został nazwany forwarder.py i można go znaleźć w katalogu głównym WeatherStation. Program rozpoczyna swoje działanie od połączenia się z brokerem o zadanym adresie IP oraz z bazą danych weather_stations w InfluxDB. Tak stworzony klient subskrybuje do zadanych tematów i nasłuchuje na wiadomości w tych tematach. Jeżeli otrzyma pomiary przez broker to wywołuje funkcje (callback), który formatuje dane i wysyła do bazy. Program działa w nieskończonej pętli i należy go wyłączyć po zakończeniu pracy. Program uruchamiamy poleceniem: $>: python forwarder.py Instalacja i konfiguracja Grafana To już ostatni krok w tworzeniu naszej stacji pogodowej. Do zainstalowania Grafany musimy najpierw sprawdzić najnowszą wersję w przeglądarce: https://github.com/grafana/grafana/releases. W tej chwili najnowsza jest wersja 6.6.0. Numer wersji umieszczamy w komendzie do pobrania i zainstalowania grafany: $>: wget https://dl.grafana.com/oss/release/grafana_6.6.0_armhf.deb $>: sudo dpkg -i grafana_6.6.0_armhf.deb $>: sudo apt-get update $>: sudo apt-get install grafana Po instalacji możemy uruchomić serwer grafana komendą w terminalu: $:> sudo service grafana-server start Dostęp do Grafany uzyskujemy na porcie 3000. Wystarczy wpisać w przeglądarce kombinację adresu IP Raspberry Pi i portu. W tym przypadku jest to 192.168.12.16:3000. Rys. 8. Widok po uruchomieniu Grafany w przeglądarce Przy pierwszym uruchomieniu wyskakuje nam okno logowania: Domyślna nazwa użytkownika i hasło to admin. Podczas pierwszego logowania możemy zmienić hasło. Teraz czas na wybranie źródła danych. Wybieramy InfluxDB. Najważniejsze pola to nazwa źródła, URL, nazwa bazy danych z której korzystamy oraz nazwa i hasło użytkownika. Zapisujemy ustawienia i przechodzimy do tworzenia panelu. Rys. 9. Źródło danych oraz widok konfiguracji panelu Tworzenie wizualizacji pulpitu nawigacyjnego odbywa się przez kliknięcie przycisku "Add panel" na górnym pasku oraz zdefiniowaniu zapytania SQL. Grafana ma ogromną ilość ustawień, ale to temat na inny artykuł. Rys. 10. Przykładowy panel w Grafanie Każdemu czytelnikowi polecam zapoznać się samemu z Grafaną. W razie pytań lub problemów, skorzystaj z sekcji komentarzy poniżej, a ja odpowiem na twoje pytania tak szybko, jak to możliwe. W załączniku został dołączony plik GrafanaWeatherStationJson, który zawiera informację o powyższym panelu. Podsumowanie W tym samouczku przeszliśmy przez całe konfiguracje stacji pogodowej od sprzętowego połączenia czujnika, przez broker MQTT aż do wizualizacji w Grafanie. Na koniec chciałbym dodać, że aplikacja została stworzona przy użyciu sprzętu firmy Dekimo Experts Delft jako część wewnętrznego projektu. WeatherStation.zip

Cześć Wam, A więc od początku Zbudowałem platformę robota z Raspberry Pi Zero na pokładzie. Do RPi podłączyłem płytkę PiMotor z L293DNE na pokładzie. Silniki zasilałem 4 bateriami NIMH co dawało z grubsza 5 V na wejściu do L293D. Niestety na mostku przez straty napięcia na silnikach napięcie wynosiło 3 V, przez co trochę brakowało mocy; optimum to 4.5V dla silników ( DAGU DG01D). Generalnie robocik jeździł. Ale... wpadłem na pomysł, aby podłączyć baterię LiPo 7.4 V 2S 20C /40C burst, (1100 mAh) licząc na optymalniejsze napięcie pracy silników. W zamian... usłyszałem huk, ujrzałem dym i ogień na układzie L293D oraz rozerwaną przetwornicę step-down TS2596 Ponieważ nie mam dużego doświadczenia z LiPO, chciałbym Was podpytać, co poszło "nie tak"? Polarność podłączona na 100% OK. Czyżby na układ poszedł jakiś potężny prąd z LiPO? Niby dlaczego? Będę wdzięczy za odpowiedź. Poniżej zdjęcia z "eksperymentu" P.S. RPi przeżyło ten szok!

MQTT jest popularnym, bo prostym w obsłudze protokołem komunikacji. Najłatwiej jest porównać to do systemu YouTube: są subskrybenci i nadawcy. Nadawca może mieć wielu subskrybentów ale też jedno urządzenie może słuchać wielu nadawców (co - trochę jak w prawdziwym życiu - nie zawsze kończy się dobrze). Cała architektura wygląda w ogólnym przypadku w następujący sposób: W tym artykule zajmiemy się przygotowaniem środowiska oraz wysłaniem “hello world”. Zakładam, że na Raspberry jest zainstalowany raspbian. Jeśli nie to koniecznie sięgnij do odpowiedniego poradnika na Forbocie. Na Raspberry możesz pracować zdalnie lub lokalnie, to nijak nie wpływa na działanie systemu. 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. Konfiguracja serwera W charakterze serwera posłuży nam Raspberry Pi. W zasadzie każdy model powinien się sprawdzić, ale zalecane jest użycie przynajmniej drugiej wersji. Aby wszystko działało jak trzeba potrzebujemy pakietu Mosquitto. Wydajemy następujące komendy: aktualizacja systemu: sudo apt-get update && sudo apt-get upgrade -y instalacja mosquitto: sudo apt-get install mosquitto -y automatyczne uruchomienie przy starcie: sudo systemctl enable mosquitto.service I… to już. Serwer został zainstalowany. Teraz jeszcze tylko restart i możemy przejść dalej. Potrzebujemy jeszcze dwa urządzenia, które będziemy ze sobą komunikować. Pierwszym z nich będzie Raspberry Pi. Będzie na nim uruchomiona usługa Node-Red dzięki której będziemy mogli w łatwy sposób odczytywać dane i sterować urządzeniami wykonawczymi. Drugie urządzenie to ESP32. Przy jego pomocy będziemy sterować diodą, która potwierdzi poprawne przejście przez instalację. Node-Red Do instalacji potrzebujemy następującej komendy: sudo apt-get install nodered -y Po skończeniu instalacji możemy dodać automatyczne uruchamianie przy starcie: sudo systemctl enable nodered.service Aby wyłączyć automatyczny start wpisujemy: sudo systemctl disable nodered.service Uruchamiamy działanie serwisu poprzez komendę: sudo node-red-start Potrzebujemy teraz poznać IP maliny (jeśli pracujemy lokalnie). Wykonujemy to poprzez: ifconfig Jeśli przechodzisz przez ten artykuł tylko “dla zajawki” to możesz poprzestać na tej komendzie. Jeśli jednak stawiasz to “na stałe” to musisz zrobić jeszcze jedną rzecz, z którą nie bardzo mogę pomóc. Należy ustawić statyczne IP dla maliny. Robi się to na routerze, w panelu administracyjnym. Ze względu na mnogość rozwiązań różnych producentów routerów musisz poszukać odpowiedni poradnik w internecie. Jak wspomniałem, jest to tylko dla osób, które stawiają serwer na stałe. Po instalacji Node-Red przechodzimy do przeglądarki. W pasku na adres url wpisujemy adres IP z portem 1880. Czyli pracując lokalnie na Raspberry wpiszemy: 127.0.0.1:1880 natomiast pracując zdalnie wpiszemy ip:1880. W moim przypadku jest to 192.168.100.194:1880. Powinniśmy dostać taki obraz: Klikamy na trzy paski w prawym górnym rogu i wybieramy opcję “Manage palette”: W oknie dialogowym przechodzimy do zakładki install i wpisujemy dashboard. Wybieramy drugą opcję z góry: Po zatwierdzeniu instalacji czekamy, aż proces się skończy. Ta wtyczka umożliwia nam utworzenie graficznego interfejsu użytkownika. Po zakończeniu instalacji zamykamy okno dialogowe i z listy po lewej stronie wybieramy opcje oraz je łączymy. Wybieramy opcje MQTT (obie) z sekcji network oraz z sekcji dashboard wybieramy switch oraz show notification. Łączymy ze sobą te punkty wg następującego schematu: Następnie dwa razy klikamy w pierwszy obiekt mqtt. Klikamy w ikonkę z ołówkiem która otworzy nam dodatkowy panel. W otrzymanym polu edycji wpisujemy tylko localhost, klikamy Add. Dalej, w polu Topic wpisujemy esp32/message i ustawiamy QoS jako 1. Podobne kroki wykonujemy dla drugiego punktu z mqtt przy czym serwer powinien zostać uzupełniony automatycznie, w polu Topic wpisujemy esp32/gpio, ustawiamy QoS jako 1 i retain jako false. Ostatni punkt w konfiguracji Node-Red to ustawienie przełącznika. Wchodzimy w jego okno dialogowe, dodajemy nową grupę (Klikamy w ołówek koło pola “Group”) znowu klikamy ołówek dalej Add i znowu Add. W ustawieniach schodzimy trochę niżej i ustawiamy On Payload jako typ number (pierwsza rozwijana ikonka) i wpisujemy 1 oraz ustawiamy Off Payload jako number i wpisujemy 0. Klikamy Deploy w prawym górnym rogu i trzymamy kciuki. Po zapisaniu zmian otwieramy nowe okno przeglądarki i wpisujemy ip:1880/ui. Pozostała część adresu zostanie uzupełniona automatycznie. Mając tak przygotowane środowisko przechodzimy do ostatniego punktu czyli modułu ESP32. ESP32 Programować będziemy w Arduino IDE. Aby jednak móc to zrobić musimy przygotować środowisko. Nie będę się zagłębiał w ten temat bo jest wiele dobrych poradników o tym w internecie (np.: tutaj) Dodatkowo w managerze bibliotek instalujemy bibliotekę PubSubClient oraz ESPMQTTClient. W fizycznym podłączeniu warto jest sprawdzić najpierw pinout naszej płytki w internecie oraz ewentualnie zmienić numer pinu w kodzie. Następnie wybieramy odpowiednią płytkę, wgrywamy przykładowy szkic i… nie działa. Po pierwsze dlatego, że należy zmienić ssid (czyli nazwy sieci, do której jest podłączone też raspberry pi), hasło oraz adres IP serwera na adres maliny. Po drugie dlatego, że często są problemy z tymi płytkami (o tym w kolejnym akapicie). Jeśli jednak udało się wszystko wgrać powinniśmy dostać wiadomość w panelu sterowania oraz możemy sterować diodą przez przełącznik. Kod testowy prezentuje się następująco: #include <WiFi.h> #include <PubSubClient.h> const char* ssid = "Nazwa wifi"; //ZMIENIC na swoje const char* password = "haslo do wifi"; //ZMIENIC na swoje const char* mqtt_server = "IP Raspberry Pi"; //ZMIENIC na swoje const char* deviceName = "ESP32"; //poki co nie trzeba zmieniac //ale przy wiekszej ilosci urzaden kazde musi miec swoja nazwe const char* startMessageTopic = "esp32/message"; //temat do wyslania wiadomosci const char* pinTopic = "esp32/gpio"; //temat do odbioru wiadomosci const int ledPin = 27; //numer pinu diody, ZMIENIC JESLI TRZEBA WiFiClient espClient; PubSubClient client(espClient); void reconnect() { bool ctd = false; //funkcja jest wywolywana jesli utracono polaczenie z serwerem Serial.println("Rozlaczono!"); while(!ctd) { Serial.print("Laczenie z serwerem..."); if(client.connect(deviceName)) { ctd = true; Serial.println("Polaczono!"); } else { Serial.print("."); delay(1000); } } } void odbiorWiadomosci(String temat, byte* zawartosc, unsigned int dlugosc) { String pomoc; Serial.println("Odebrano wiadomosc:"); Serial.print("\tTemat: "); Serial.println(temat); Serial.print("\tTresc: \""); for(int i=0; i<dlugosc; i++) { Serial.print((char)zawartosc[i]); pomoc += (char)zawartosc[i]; } Serial.println("\""); if(temat == pinTopic) { if(pomoc == "1") { digitalWrite(ledPin, HIGH); Serial.println("LED1: ON"); } else if(pomoc == "0") { digitalWrite(ledPin, LOW); Serial.println("LED1: OFF"); } else Serial.println("Nieznana komenda, nie wiem co mam z tym zrobic"); } } void ustawienieWifi() { delay(10); Serial.println(); Serial.print("Laczenie z "); Serial.println(ssid); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.print("Polaczona z wifi.\nESP otrzymalo adres IP: "); Serial.println(WiFi.localIP()); } void setup() { Serial.begin(115200); pinMode(ledPin,OUTPUT); ustawienieWifi(); //polaczenie z wifi delay(1000); client.setServer(mqtt_server, 1883); //ustawienie serwera mqtt client.connect(deviceName); //polaczenie z podana nazwa client.subscribe(pinTopic); //ustawienie nasluchiwania w podanym temacie client.setCallback(odbiorWiadomosci); //ustawienie funkcji do odbioru wiadomosci client.publish(startMessageTopic, "Hello from ESP32"); //wyslanie pierwszej wiadomosci } void loop() { if (!client.connected()) //jesli klient zostal rozlaczony { reconnect(); //polacz ponownie client.publish(startMessageTopic, "Hello from ESP32"); //wysliij wiadomoc powitalna } if(!client.loop()) client.connect(deviceName); //upewnienie sie, ze klient jest stale podlaczony } Jako, że jest to pierwszy kontakt z tym protokołem i programem pozwolę sobie nie zagłębiać się w szczegóły. Starałem się wszystko opisać w komentarzach kodu. Dodatkowo dużo rzeczy jest wyświetlanych w konsoli, więc warto tam zajrzeć. Problemy, problemy, problemy Często zdarza się tak, że płytki z rodziny ESP nie współpracują ze wszystkimi komputerami. W moim przypadku na 4 komputery bez problemu mogę podłączyć się z dwóch. Z jednego muszę używać programatora FTDI a jeden (najnowszy) działa trochę jak ślepy koń: nie widzi przeszkód (a w zasadzie nie widzi płytek). Jeśli natomiast są problemy przy wygrywaniu można spróbować wybrać inną płytkę w ustawieniach IDE lub pomajstrować z ustawieniami wybranej płytki (znowu odsyłam do internetu, źródeł trochę jest). Osobiście pracowałem na płytce Esp32 Wroom, a wgrywanie działało przy ustawieniach dla płytki LOLIN D32.