Każdy z nas – rozwijających swój inteligentny dom, chciałby mieć podgląd na ulice wokół swojego domu. Cel? Podgląd korków, obserwacja sąsiadów etc.

Na szczęście jest coś takiego jak traxelektronik.pl.

To firma która regularnie pokrywa nasz kraj kamerami a co więcej obraz z nich udostępnia na swoich stornach internetowych.

Dodając do tego HOME ASSISTANT i scrape sensor – możemy uzyskać to co chcemy.

 

Jak to zrobić?

Na początku wyszukujemy interesujące nas kamery na stronie:  https://www.traxelektronik.pl/pogoda/kamery/index.php

Następnie wybieramy interesującą nas miejscowość i zapamiętujemy adres z przeglądarki

 

W demonstrowanym przypadku naszym adresem będzie:

https://www.traxelektronik.pl/pogoda/kamery/kamera.php?pkamnum=1960

No i teraz do dzieła. W home assistant definiujemy sensory typu scrape jak w poniższym listingu:


# kamerki zewnętrzne, skrapowanie
# https://www.traxelektronik.pl/pogoda/kamery/

- platform: scrape
  resource: https://www.traxelektronik.pl/pogoda/kamery/kamera.php?pkamnum=1960
  name: Url kamera traxel skawina (na rzeszów)
  id: url_kamera_traxel_skawina_na_rzeszow
  select: "#kam1 ~ a:nth-of-type(4)"
  #kam1 - numer kolejnej kamery
  value_template: >-
    {{ value.split("'")[1] }}
  attribute: href
  scan_interval: 60

- platform: scrape
  resource: https://www.traxelektronik.pl/pogoda/kamery/kamera.php?pkamnum=1960
  name: Url kamera traxel skawina (na katowice)
  id: url_kamera_traxel_skawina_na_katowice
  select: "#kam0 ~ a:nth-of-type(4)"
  #kam1 - numer kolejnej kamery
  value_template: >-
    {{ value.split("'")[1] }}
  attribute: href
  scan_interval: 60
* Z uwagi, że WP wycina niektóre znaki, plik ten do pobrania jest również artykułu. (Jeśli ktoś sobie z tym poradził – proszę o info)

 

U mnie definicja sensorów znajduje się w pliku sensor.yaml (polecam osobny plik).

Jeżeli u Ciebie sensory definiowane są w pliku configuration.yaml – musisz dodać wpis:

sensor:

przed definicją sensorów.

Nie będę opisywał szczegółowo jak działa sensor scrape. W skrócie… wykorzystując tak zwane selektory CSS wyszukujemy zdjęcie kamery:

select: “#kam0 ~ a:nth-of-type(4)”

A następnie wyciągamy potrzebną informację za pomocą:

value_template: >- {{ value.split(“‘”)[1] }} attribute: href

I proces ten przeprowadzamy dla każdej kamery którą chcemy mieć w swoim systemie inteligentnego domu.

 

Pozostaje kwestia definicji kamer. Realizujemy to za pomocą standardowej kamery HA generic. Poniżej skrypt:

# drogowe 
- platform: generic
  name: skawina (na rzeszów)
  id: traxel_skawina_na_rzeszow
  still_image_url: >-
    {{ states('sensor.url_kamera_traxel_skawina_na_rzeszow') }}

- platform: generic
  name: skawina (na katowice)
  id: traxel_skawina_na_katowice
  still_image_url: >-
    {{ states('sensor.url_kamera_traxel_skawina_na_katowice') }}

U mnie definicja kamer znajduje się w pliku camera.yaml (polecam osobny plik).

Jeżeli u Ciebie kamery definiowane są w pliku configuration.yaml – musisz dodać wpis:

camera:

przed definicją kamer.

 

Tak zdefiniowane kamery stają się widoczne w naszym panelu home assistant. U mnie dziś pada:-)

 

Pliki do artykułu:

camera.yaml, sensor.yaml > homeasistant-kamery-scrap-sensor

 

W sieci jest wiele materiałów na temat integracji TV PHILIPS z domoticz i home assistant. Niestety nie znalazłem rozwiązań realizujących moje dwie potrzeby. A jakie one są?

  1. Wyłączanie telewizora – np. wyjście z domu, sen etc.
  2. Włączanie telewizora z obsługą wakeonlan – np. uruchomienie wiadomości porannych w ramach pobudki.

Zaznaczę, że w moim przypadku źródłem sygnałów AV jest amplituner, więc mam trochę prościej.

W przypadku telewizorów PHILIPS w rocznikach >=2016 wymagana jest dodatkowa autentykacja urządzeń sterujących.

Przeprowadzamy ją za pomocą skryptu philps.py ja pobrałem go z stąd:

https://github.com/suborb/philips_android_tv/blob/master/philips.py

Skrypt uruchamiamy tak:

python philips.py --host 192.168.1.154 pair

gdzie 192.158.1.154 to adres ip naszego telewizora w sieci

Po uruchomieniu podajemy passcode (w telewizorze) a następnie odczytujemy username i password w postaci:


Username for subsequent calls is: 2xqDUOQfIjGxqL4M

Password for subsequent calls is: ccf9b46f9bb9a7efdf929fe8c0968cf1761bc5518fa8f99750096752b40217fd

Po takim sparowaniu za pomocą CURL możemy rozpocząć proces sterowania telewizorem.

Przykładowe komendy:


# wyłączenie:

curl -s --insecure --anyauth --user USER:PASS -H "Accept: application/json" -X POST -d "{\"key\":"Standby"}" <a href="https://192.168.1.154:1926/6/input/key">https://192.168.1.154:1926/6/input/key</a>

# status:

curl -s --insecure --anyauth --user USER:PASS -H "Accept: application/json" -X GET <a href="https://192.168.1.154:1926/6/system">https://192.168.1.154:1926/6/system</a>

#Audio, głośność

curl -s --insecure --anyauth --user USER:PASS -H "Accept: application/json" -X POST -d "{\"muted\":false,\"current\":0}" <a href="https://192.168.1.154:1926/6/audio/volume">https://192.168.1.154:1926/6/audio/volume</a>

# aktualny tryb pracy

curl -s --insecure --anyauth --user USER:PASS -H "Accept: application/json" -X GET <a href="https://192.168.1.154:1926/6/powerstate">https://192.168.1.154:1926/6/powerstate</a>

 

odpowiednio USER:PASS to w moim przypadku: 2xqDUOQfIjGxqL4M:ccf9b46f9bb9a7efdf929fe8c0968cf1761bc5518fa8f99750096752b40217fd

Więcej komend można znaleźć tu: http://jointspace.sourceforge.net/projectdata/documentation/jasonApi/1/doc/API.html

I wszystko by było fajnie, poza jedną małą rzeczą. Uśpionego PHILIPSa nie da wybudzić się za pomocą powyższych metod.

Z pomocą przychodzi pakiet WAKEONLAN. Instalacja:


sudo apt-get install wakeonlan

Tak więc jeżeli puścimy MAGIC PACKET (WAKEONLAN) na nasz TV PHILPS, odczekamy aż zacznie pingować i a następnie wywołamy komendę STANDBY – skutecznie włączymy nasze urządzenie.

Poniżej skrypt tv.sh w shellu realizujący powyższy proces:


#!/bin/bash

#setup
hostip=192.168.69.70
hostmac=70:af:24:11:9f:8b
user=bJA8dKn2zGOiOPCt
pass=dac73bd9961a8525a0e318b68002c5d6c93b89b310664152045ba1444c2a6304

#parametry

status=0
off=0
on=0
ha=0

# ha - home assistant support

while [ -n "$1" ]; do
case "$1" in
-status) status=1 ;;
-ha) ha=1 ;;
-on) on=1 ;;
-off) off=1 ;;
*) echo "$1 - nierozpoznany parametr" ;
esac
shift
done

if [ $ha = 1 ] && [ $status = 1 ] ; then
sleep 3
fi

getcmd="curl -s --max-time 2 --insecure --anyauth --user $user:$pass -H \"Accept: application/json\" -X GET https://$hostip:1926/6/CMD"
keycmd="curl -s --max-time 2 --insecure --anyauth --user $user:$pass -H \"Accept: application/json\" -X POST -d \"{\\\"key\\\":\"KEY\"}\" https://$hostip:1926/6/input/key"

getpowerstatecommand=${getcmd/CMD/powerstate}
jsonres=$(eval $getpowerstatecommand)
powerstate=$(jq -r '.powerstate' <<< ${jsonres})

#obsluga cmd

if [ -z "$powerstate" ] ; then
powerstate="Off"
fi

if [ $status = 1 ] ; then
if [ $ha = 1 ] ; then
if [ "$powerstate" == "On" ] ; then
exit 0
else
exit 1
fi
else
echo "$powerstate"
fi
fi

#tv jest wyłączony, robimy budzenie, potem włączenie
if [ $on = 1 ] && [ "$powerstate" == "Off" ] ; then
wakeonlan "$hostmac"
((count = 20))
while [[ $count -ne 0 ]] ; do
ping -c 1 "$hostip" > /dev/null
rc=$?
if [[ $rc -eq 0 ]] ; then
((count = 1))
fi
((count = count - 1))
done

if [[ $rc -eq 0 ]] ; then
sleep 5
cmd=${keycmd/KEY/Standby}
eval $cmd
fi
fi

if [ $on = 1 ] && [ "$powerstate" == "Standby" ] ; then
cmd=${keycmd/KEY/Standby}
eval $cmd
fi

if [ $off = 1 ] && [ "$powerstate" == "On" ] ; then
cmd=${keycmd/KEY/Standby}
eval $cmd
fi

Skrócona instrukcja:

Możliwe wywołania:
tv.sh -status : zwraca status aktualny telewizora
tv.sh -on : wlacza telewizor
tv.sh -off : wylacza telewizor

Potrzebne:

jq – JSON command utility (bo będę się pewnie więcej bawił JSONem)
wakeonlan – magic packet utility

Instalacja jq:

cd /tmp
wget https://github.com/stedolan/jq/releases/download/jq-1.5/jq-1.5.tar.gz
tar xfvz jq-1.5.tar.gz
cd jq-1.5
./configure && make && sudo make install

Instalacja wakeonlan:

apt-get install wakeonlan

 

Na koniec dla użytkowników HOME ASSISTANT kawałek z configuration.yaml

 

switch:
  platform: command_line
  switches:
    tv:
      command_on: "/home/pi/scripts/tv/tv.sh -on"
      command_off: "/home/pi/scripts/tv/tv.sh -off"
      command_state: "/home/pi/scripts/tv/tv.sh -status -ha"
      friendly_name: Telewizor PHILIPS

Postanowiłem zainstalować w domu alarm:-)

Cel?

Zabezpieczenie mieszkania przy poniższych założeniach:

  1. NAJWAŻNIEJSZE – Alarm ma być niezależny od domowego systemu zarządzania, DOMOTICZ nie działa – alarm działa
  2. Alarm ma pozwolić na wykorzystanie podłączonych pirów, innych czujników w systemie DOMOTICZ (analiza ruchu, zarządzanie oświetleniem)
  3. DOMOTICZ / HOME ASSISTANT  powinien umieć sterować wyjściami OUT alarmu
  4. DOMOTICZ / HOME ASSISTANT powinien umieć uzbroić/rozbroić  alarm – głównie chodzi o włączenie alarmu dla strefy nocnej (mój manipulator będzie przy drzwiach wejściowych, więc chcę móc załączać alarm nocny innym urządzeniem – np. switch XIAOMI)
  5. DOMOTICZ / HOME ASSISTANT powinien wiedzieć kiedy alarm jest uzbrojony – po uzbrojeniu powinien umieć wyłączyć urządzenia typu telewizor, żelazko, amplituner ..

Wstępne rozpoznanie urządzeń wskazało na SATEL INTEGRA 32 + ETHM1plus (400pln) + dedykowany kabel dedykowany połączeniowy (40 pln).
Wszyscy polecają, wszyscy go mają, działa z DOMOTICZ.

Poszukałem innych rozwiązań dostępnych na rynku i postanowiłem zaryzykować – bo spodobały mi się możliwości systemu ROPAM NEOGSM-IP – a tak będąc do końca szczerzy zostałem lekko ukierunkowany przez dobrego sprzedawcę, który zapewniał, że powyższe cele osiągnę właśnie z tym urządzeniem.

Jako, że nie jestem instalatorem, samo podłączenie urządzenia zajęło mi trochę czasu. Traktuję to jako zabawę połączoną z nauką,  więc czas na pewno nie uważam za zmarnowany.

Po kilku próbach, udało się skonfigurować urządzenie z jednym pirem, syreną i kartą GSM. Poniżej schemat który mi mocno pomógł, może kiedyś pomoże i Wam.

 

 

Pozostała kwestia integracji z DOMOTICZ.

Niestety na forum firmy ROPAM (link) możemy dowiedzieć się, że z tą centralką integracja nie jest możliwa.
Stwierdzenie “coś jest nie możliwe” jest mocno motywujące, tak więc wykorzystując jedną z moich ulubionych technik czyli Reverse Engineering postanowiłem mimo wszystko dokonać integracji.

Udało się.

W poniższym linku udostępniam program pozwalający na integrację systemu ROPAM NEOGSM-IP i DOMOTICZ HOME ASSISTANT i pewnie też z OPENHAB którego nie znam.

ropam-neogsm-domoticz-homeassistant-integrator

Program potrafi pracować jako usługa lub aplikacja konsolowa. Został napisany w technologii Microsoft .NET, ale, że zarówno ja, jak i większość z użytkowników systemu DOMOTICZ / HOME ASSISTANT korzysta z rozwiązania opartego o system LINUX, Raspberry … postanowiłem go uruchomić właśnie w tym środowisku.

I po raz kolejny udało się:-)

Poniżej kroki które należy uczynić by aplikacja zadziała na Raspberry:

  1. Instalujemy środowisko MONO (użyłem pełnej wersji, bo będę się jeszcze mocniej bawił)
    sudo apt-get install mono-complete
  2. Instalujemy MONO-SERVICE
    sudo apt-get install mono-4.0-service
  3. Pobieramy pliki programu do integracji z tego linka: ropam-neogsm-ip-dmoticz-intergracja
  4. Wrzucamy pobrane pliki (po rozpakowaniu) do docelowego katalogu (u mnie /home/pi/@scripts/neo/)
  5. Tworzymy plik uruchamiający usługę w katalogu naszego programu
    sudo nano xneoapi.sh

    Zawartość pliku:

    #!/bin/bash
    cd /home/pi/@scripts/neo/
    sudo mono-service -l:/var/run/lock/xneoapi.lock /home/pi/@scripts/neo/xneoapi.exe
    
  6. Nadajemy uprawnienia do uruchamiania skryptu
    sudo chmod +x xneoapi.sh
  7. Edytujemy plik /etc/rc.local wpisując:
    sudo nano /etc/rc.local
  8. Dodajemy poniższy wpis odpowiedzialny za automatyczne uruchamianie naszej usługi po restarcie Rasberrergo
    sudo /home/pi/@scripts/neo/xneoapi.sh
    
    

Pozostaje jeszcze kwestia integracji programu.

  1. Parametry pracy programu – plik xneoapi.exe.conf

     <applicationSettings>
            <X.NEO.API.Properties.Settings>
                <setting name="WebServerPrefix" serializeAs="String">
                    <value>http://localhost:7999/</value>
                </setting>
                <setting name="NeoGsmDeviceIp" serializeAs="String">
                    <value>192.168.1.100</value>
                </setting>
                <setting name="NeoGsmDevicePort" serializeAs="String">
                    <value>9999</value>
                </setting>
                <setting name="NeoGsmMainBoardId" serializeAs="String">
                    <value>1500067240999999</value>
                </setting>
                <setting name="NeoGsmUserCode" serializeAs="String">
                    <value>1234</value>
                </setting>
                <setting name="NeoGsmTcpCode" serializeAs="String">
                    <value>dac281bf43999999</value>
                </setting>
                <setting name="RunAsService" serializeAs="String">
                    <value>False</value>
                </setting>
                <setting name="Simulation" serializeAs="String">
                    <value>False</value>
                </setting>
            </X.NEO.API.Properties.Settings>
        </applicationSettings>
    

    Parametry związane z urządzaniem NeoGsm nie będę omawiał a pozostałe to:

    WebServerPrefix – prefixy dla naszego API, pod tymi adresami dostępne będzie API i strona informacyjna – jeżeli bedzie to kilka interfejsów, oddzielamy średnikami
    RunAsService – czy usługa będzie uruchomiona jako serwis czy jako aplikacja konsolowa [True|False]
    Simulation – odpala aplikacje w trybie symulacji, działa tylko WebServer bez połączenia z centralką alarmową [True|False]

  2. Parametry powiadomień systemów zewnętrznych (np. DOMOTICZ / HOME ASSISTANT)  – znajdują się w pliku notification.xml – tam raczej wszystko jest jasne, jeśli nie proszę o informację zwrotną.
    <?xml version="1.0" encoding="utf-8"?>
    <Notification xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <Inputs>
    <NotificationInput>
    <Id>0</Id>
    <OnActivate>http://192.168.1.101:8080/json.htm?type=command&amp;param=udevice&amp;idx=236&amp;svalue=1</OnActivate>
    <OnDeactivate>http://192.168.1.101:8080/json.htm?type=command&amp;param=udevice&amp;idx=236&amp;svalue=0</OnDeactivate>
    </NotificationInput>
    </Inputs>
    <Zones>
    <NotificationZone>
    <Id>0</Id>
    <OnArm>http://user:password@192.168.0.1:8080/json.htm?type=command&amp;param=udevice&amp;idx=3&amp;svalue=0</OnArm>
    <OnDisarm>http://user:password@192.168.0.1:8080/json.htm?type=command&amp;param=udevice&amp;idx=3&amp;svalue=1</OnDisarm>
    </NotificationZone>
    </Zones>
    </Notification>
  3. Parametry logowania zdarzeń znajdują się w pliku NLOG.config – instrukcja jak go modyfikować znajduje się pod adresem: https://nlog-project.org/

Po uruchomieniu aplikacji, pod adresem wskazanym w parametrze WebServerPrefix dostępna będzie strona API.

Aplikacja jest w wersji mocno rozwojowej – najnowsza jej wersja działa już produkcyjnie ale czekam na Wasze pytania, propozycje modyfikacji.

Od jakiegoś czasu rozglądałem się za kamerką IP z możliwością zdalnego obracania w możliwie najszerszym zakresie.

Wybór padł na OVERMAX CAMSPOT 3.3.

Dlaczego?

Cena:)

Sama kamerka działa bardzo przywozicie.

Dostarczone oprogramowanie (windows) pozwala na podgląd, zdalne obracanie kamerką oraz komunikację dwu-stroną – kamera wyposażona jest zarówno w głośnik jak i mikrofon (mocno marna jakość)

Dodatkowo producent dostarcza wtyczkę activeX dla IE pozwalającą wykorzystać wszystkie funkcjonalności kamery z poziomu przeglądarki.

Pozostałe przeglądarki oferują podgląd wraz z możliwością obracania – co  i tak jest dobrym rezultatem.

W nocy 6 diod podczerwieni skutecznie rozświetla pomieszczenie o wymiarach ~6×3.

Kamerka została u mnie podpięta pod SYNOLOGY Surveillance Station  i DOMOTICZ

I jak to zawsze u mnie, sprzęt kupowany, nie do końca wspierany jest przez dostawców oprogramowania, więc zdradzam co należy uczynić by się cieszyć zakupem.

  1. SYNOLOGY Surveillance Station – kamerka działa prawidłowo jako urządzenie ONVIF – tu nie było większych problemów.Wybieramy odpowiednio:
    Marka – [ONVIF]
    Model kamery:  [Generic_ONVIF]i działa.
  2. Domoticz – i tu pojawiły się schody. Kamera w standardzie dostarcza  plik w formacie MJPEG pod adresem:videostream.cgi?user=[USERNAME]&pwd=[PASSWORD]&resolution=32&rate=0i faktycznie tak jest.

    MJPEG – (Motion JPEG, M-JPEG) – standard kompresji danych, obraz składa się z szeregu pojedynczych obrazów w formacie JPEG. Każda ramka jest oddzielnie kompresowana, nie ma też kodowania między-klatkowego (np. analizy ruchu/predykcji która występuje choćby w H.264). Jest to metoda wymagająca małej mocy obliczeniowej – nie obciąża procesora w rejestratorze, nie potrzebuje też wiele pamięci operacyjnej

    Niestety Domoticz kiepsko sobie radzi z tym formatem, niby przy parametryzowaniu kamery wyświetla prawidłowo przechwyconą klatkę, ale w podglądzie już nie.
    Dokumentacji zero, więc na chybił trafił rozpocząłem poszukiwania rozwiązania i po kompilacji kilkunastu adresów z innych modeli, okazało się, że OverMax Camspot 3.3 ma zwykłego jpega w lokalizacji:

    cgi/snapshot.cgi&user=[USERNAME]&pwd=[PASSWORD]&resolution=32&rate=0

    po wprowadzeniu do Domoticz .. działa:-)

 

 

 

 

Jeśli nie posiadasz jeszcze czujnika stężenia cząstek, zanieczyszczenia powietrza – nic straconego.

Dzięki sieci AIRLY możesz czerpać dane z czujników innych użytkowników.

Jak to zrobić?

  1. Uruchamiamy konsolę.
  2. Przechodzimy do katalogu przeznaczonego na pluginy w systemie DOMOTICZ, pobieramy najnowszą wersję pluginu AIRLY-DOMOTICZ a następnie restartujemy naszą usługę
    cd domoticz/plugins
    git clone https://github.com/lrybak/domoticz-airly
    sudo service domoticz.sh restart
    
  3. Zakładamy konto na https://developer.airly.eu/login
  4. Pobieramy API KEY ze strony https://developer.airly.eu/api
  5. W systemie DOMOTICZ dodajemy nowy sprzęt KONFIGURACJA>SPRZĘT
    • typ domoticz-airly
    • Airly API key pobrany ze strony
    • Airly Sensor id: identyfikator czujnika który chcemy monitorować – pobieramy go ze strony https://airly.eu/beta/pl/ , klikając na punkcie który chcemy monitorować i kopiując ID z adresu – patrz rysunek poniżej

  6. Po dodaniu sprzętu pojawi się on czujnikach użytkowych

 

 

 

 

 

Zainspirowany skryptem znalezionym w necie postanowiłem uruchomić proces mierzący czas pinga, prędkość downloadu i uploadu mojego dostawcy internetu.

Konfiguracja w DOMOTICZ sprowadza się do zdefiniowana wirtualnych sensorów poprzez:

  1. KONFIGURACJA>SPRZĘT>DODAJ

  2. Na dodanym sprzęcie klikamy UTWÓRZ WIRTUALNE CZUJNIKI
  3. Dodajemy odpowiednio czujniki dla PING, DOWNLOAD, UPLOAD, wybierając typ czujnika CUSTOM SENSOR  a w etykiecie AXIS wprowadzamy jednostkę w której chcemy wykonywać pomiary – u mnie odpowiednio ms dla PING, i Mbit/s dla DOWNLOAD i UPLOAD

  4. Następnie z pozycji KONFIGURACJA>URZĄDZENIA odczytujemy IDXy naszych czujników – będą potrzebne do konfiguracji skryptu.

Do pomiaru prędkości złącza wykorzystamy pakiet speedtest. Jego instalacja sprowadza się do uruchomienia poniższej komendy.

sudo apt-get install speedtest-cli

Uruchomienie standardowe poprzez komendę speedtest zwraca komplet potrzebnych informacji.
Uruchomienie go z parametrem –simple ograniczy ilość zwracanych danych, co pozwoli nam łatwiej je obrobić.
Do obróbki wykorzystałem linuxowy program sed

Kompletny skrypt zamieszczam poniżej:

#!/bin/bash

#setup
pingidx=47
downloadidx=45
uploadidx=46
</pre>
#pobieranie danych
speedtest --source 192.168.1.101 --simple > speedtest.dat
ping=$(sed -n -E '1s/Ping: | ms//gp' speedtest.dat)
download=$(sed -n -E '2s/Download: | Mbit\/s//gp' speedtest.dat)
upload=$(sed -n -E '3s/Upload: | Mbit\/s//gp' speedtest.dat)

echo $ping
echo $download
echo $upload

curl -s -i -H "Accept: application/json" "http://$user:$password@$host:$port/json.htm?type=command&param=udevice&idx=$pingidx&svalue=$ping"
curl -s -i -H "Accept: application/json" "http://$user:$password@$host:$port/json.htm?type=command&param=udevice&idx=$downloadidx&svalue=$download"
curl -s -i -H "Accept: application/json" "http://$user:$password@$host:$port/json.htm?type=command&param=udevice&idx=$uploadidx&svalue=$upload"

sed w dużym skrócie potrafi odpowiednio manipulować tekstami, w naszym przypadku wyciąga potrzebne dane z rezultatu zwracanego przez speedtest. Spreparowane dane  następnie przysyłamy do systemu DOMOTICZ w wykorzystaniem jego API. Oczywiście powyższy skrypt musicie zmodyfikować poprzez wprowadzenie własnych IDXów i adresu DOMOTICZ.

Aby uruchomić skrypt musimy mu jeszcze nadać odpowiednie uprawnienia poprzez wydanie komendy:

chmod +x speedtest.sh

(mój plik nazywa się speedtest.sh)

Na koniec aby to okresowo sprawdzać prędkość złącza musimy włączyć harmonogram odpalania skryptu.

Realizujemy to poprzez wrzucenie odpowiedniego wpisu do crontaba. Tak więc:

1. Uruchamiamy crontaba:

crontab -e

2. Dodajemy nowy wpis:

0 * * * * /home/pi/domoticz/scripts/shell/speedtest.sh

Czyli w moim przypadku skrypt będzie uruchamiany w każdej zerowej minucie godziny – czyli co godzine;-).

Więcej o harmonogramie w crontabie możecie znaleźć TU

Efekt końcowy na obrazkach poniżej:-)

Ktoś kiedy powiedział, że “ludzie dzielą się na tych co robią backup i na tych co dopiero będą go robić” .

Cel

Wykonanie kopi dla:

  • baza SQLITE DOMOTICZ
  • katalog skryptów DOMOTICZ
  • katalog www DOMOTICZ (nie wiem po co , ale widziałem, że inni to robią)
  • inne katalogi które mogą okazać się przydatne

Kopia taka powinna zostać skompresowana i przesłana za pomocą ftp na wskazany adres. U mnie to będzie dysk SYNOLOGY który właśnie pełni rolę rodzinnego serwera backupowego.

Po kilku próbach skomponowałem skrypt poniższy skrypt:


#!/bin/bash

# parametry

ftpHost="192.168.1.100"
ftpUser="nazwauzytkownika"
ftpPass="haslouzytownika"
ftpDestDirectory="backup/"

domoticzHost="192.168.1.101"
domoticzPort="8080"

domoticzDirectory="/home/pi/domoticz"
domoticzDirectoryWww="$domoticzDirectory/www"
domoticzDirectoryScripts="$domoticzDirectory/scripts"

scriptDirectory="/home/pi/@scripts"

now=$(date '+%Y%m%d%H%M%S')
backupDirectory="/tmp/backup_$now"
backupFile="/tmp/backup_raspberry_$now.tar"

echo "zakładam katalog dla kopii $backupDirectory"
mkdir $backupDirectory

echo "backup - domoticz db ..."
curl -s http://$domoticzHost:$domoticzPort/backupdatabase.php > $backupDirectory/domoticz.db

echo "backup - domoticz pliki (www) ... "
cp -r $domoticzDirectoryWww $backupDirectory

echo "backup - domoticz pliki (skrypty) ... "
cp -r $domoticzDirectoryScripts $backupDirectory

echo "backup - skrypty ..."
cp -r $scriptDirectory $backupDirectory

echo "pakowanie ..."
tar -zcvf $backupFile $backupDirectory

echo "ftp transfer ..."
curl -s --disable-epsv -v -T"$backupFile" -u"$ftpUser:$ftpPass" "ftp://$ftpHost/$ftpDestDirectory"

echo "usuwam tmp pliki ..."
rm -r $backupDirectory
rm $backupFile

curl --silent -u """pushbulletapikey"":" -d type="note" -d body="backup został wykonany. (f:$now)" -d title="raspinfo" 'https://api.pushbullet.com/v2/pushes'

 

W ostatniej linii skryptu wysyłam wiadomość o wykonaniu backupu za pomocą wcześniej skonfigurowanego pushbulleta.

Jak go skonfigurować pisałem TU.

Aby uruchomić skrypt musimy mu jeszcze nadać uprawnienia poprzez wydanie komendy:

chmod +x backup.sh

(mój plik nazywa się backup.sh)

Na koniec aby to wszystko miało sens musimy włączyć harmonogram odpalania skryptu.

Realizujemy to poprzez wrzucenie odpowiedniego wpisu do crontaba. Tak więc:

1. Uruchamiamy crontaba:

crontab -e

2. Dodajemy nowy wpis:

0 3 * * 1 /home/pi/@scripts/backup.sh

Czyli będziemy odpalać skrypt w poniedziałki o 3:00.

Więcej o harmonogramie w crontabie możecie znaleźć TU

 

Będąc na co dzień użytkownikiem systemu MS Windows 10 zachwycam się prostotą pewnych rzeczy na raspberry.

Jedną z nich jest wysyłanie wiadomości przez aplikację PUSHBULLET za pomocą basha.

Jak to się robi?

curl --silent -u """Twoj_APIKey"":" -d type="note" -d body="treść wiadomości" -d title="title wiadomości" 'https://api.pushbullet.com/v2/pushes'

Oczywiście wcześniej należy zainstalować darmową aplikację PUSHBULLET oraz w miejscu Twoj_APIKey wprowadzić wartość podaną przez pushbulleta.

Jak uzyskać APIKEY na rysunku poniżej.

 

 

 

 

Czasami potrzebujemy wiedzieć czy nasze urządzenia sieciowe takie router, przekaźniki SONOFF działają poprawnie – są widoczne w sieci.  Osobiście też, lubię posiadać wiedzę o ewentualnym braku internetu – pomocne przy negocjacjach z dostawcą internetu.

Tradycyjnie możemy realizować to za pomocą pinga. Możemy też do tego celu wykorzystać naszą instalację DOMOTICZ.

Jak to zrobić?

  1. Konfiguracja > Sprzęt > Typ: System Alive Checker (Ping) [1]
  2. Po dodaniu, pojawia się on na naszej liście sprzętów, klikamy [Konfiguracja]
  3. W węzłach podajemy adresy IP monitorowanych zasobów.  podając również limit czasu – przez ile będziemy czekać na pinga [2]
  4. Po wykonaniu tych czynności DOMOTICZ doda nam nowe urządzenia o nazwach zdefiniowanych na etapie definicji węzłów.
  5. Dodajemy je do pulpitu (zielona strzałka), podając czytelne nazwy [3]
  6. Po pojawieniu się w pulpicie [4] –  cieszymy się logami z niedziałających urządzeń:-) [5]

 

* W przypadku przeglądania logów, będą widoczne zmiany stanu pingowania, a nie każdy pojedynczy ping.

 

Rysunki wspomagające:

[1]

[2]

[3]

[4]

[5]

Dostaliśmy w prezencie dekoracyjne kule LED w kolorze białym. Uznaliśmy, że skoro posiadają pewien poziom wodoodporności ich miejsce powinno być na balkonie.

Lampki same w sobie nie posiadają włącznika, a uruchomienie ich następuje przez umieszczenie wtyczki w gniazdku. Proste i niezawodne rozwiązanie.

No zaraz, ale miało być inteligentnie.

Cel

Po zmroku lampki mają się zapalić, odczekać 2-3 godziny po których powinny się samoczynnie zgasić.

Instalacja

Co będzie potrzebne?

  • Lampki (lidl|bierdornka) ~35pln
  • Przełącznik SONOFF BASIC (aliexpress) ~20pln
  • Obudowa wodoodporna (aliexpress) ~15pln
  • Konwerter USB to TTL CP2102 Arduino (allegro) ~12pln
  • Narzędzia (kabelki, lutownica, cyna)
  • Oprogramowanie alternatywne do SONOFF BASIC np. ESPEASY, AFE
  • NodeMCU Flasher

Z uwagi na patriotyzm postanowiłem dać szansę polskiemu alternatywnemu oprogramowaniu –  AFE .

Dokładny opis wgrania softu znajduje się pod linkiem https://www.smartnydom.pl/firmware-sonoff/instalacja/

W moim przypadku urządzenie po zmianie softu nie działało prawidłowo. Wszystkie problemy rozwiązało wyczyszczenie pamięci SONOFFa przez wgranie tzw blanka. Instrukcja wgrywania do pobrania TU

Jeżeli nie czujesz się na siłach w starciu z lutownicą i nie masz czasu na rozwiązywanie ewentualnych problemów  – możesz zakupić SONOFFa na allegro już z wgranym oprogramowaniem lub zamówić jego wgranie do posiadanych sztuk.

Konfiguracja

Po pierwszym uruchomieniu SONOFFa z nowym oprogramowaniem rozpoczyna on pracę w trybie ACCESS POINT udostępniając otwartą sieć o nazwie AFE-Device

Postępujemy wg schematu:

  • Podłączamy się do sieci AFE-Device
  • W przeglądarce odpalamy adres http://192.168.5.1
  • W ustawieniach konfigurujemy na razie wyłącznie parametry podłączenia do naszej sieci (to wystarczy)
  • Zapisujemy konfigurację klikając [Zapisz konfigurację]

Warto przypisać urządzeniu adres IP poprzez ustawienia DHCP na routerze, lub bezpośrednio w konfiguracji SONOFFa.

Po restarcie urządzenia stanie się ono widoczne w naszej sieci pod adresem skonfigurowanym w sekcji Sieć Wifi

Konfigurację systemu DOMOTICZ przeprowadzamy według poniższej instrukcji:

  1. KONFIGURACJA>SPRZĘT>DODAJ dodajemy nowy sprzęt typu Dummy (Does nothing, use for virtual switches only)  nazywając go np. włączniki sonoff



  2. Klikając Utwórz wirtualne czujniki dodajemy nowe urządzenie o nazwie pod jaką będzie widoczne w naszym systemie i typie “Przełącznik”



  3. Odczytujemy i zapamiętujemy IDX z poziomu KONFIGURACJA>URZĄDZENIA.



  4. Oznaczamy nasze urządzenie jako używane, poprzez kliknięcie zielonej strzałeczki.
  5. Przechodzimy do opcji z menu głównego PRZEŁĄCZKI
  6. Klikając EDYCJA modyfikujemy pola (oczywiście podając własny adres IP urządzenia)
    WŁĄCZ AKCJĘ: http://192.168.1.200/?device=relay&name=switch&command=on&source=domoticz
    WYŁĄCZ AKCJĘ: http://192.168.1.200/?device=relay&name=switch&command=off&source=domoticz

 

Po tej operacji nasz przełącznik będzie już widoczny z poziomu systemu DOMOTICZ a co za tym idzie będzie go można włączać z zdalnie.

Pozostało jeszcze skonfigurowanie komunikacji w kierunku SONOFF > DOMOTICZ. Chcielibyśmy mieć możliwość informowania systemu DOMOTICZ o ewentualnie analogowym przełączeniu SONOFFa.

Realizujemy to poprzez:

  1. Wchodzimy w ustawienia oprogramowania AFE wpisując w przeglądarce adres IP przełącznika.
  2. W opcjach MENU>URZĄDZENIE zaznaczamy opcję Domoticz API włączone?


  3. W opcjach MENU>PRZEKAŹNIK ustawiamy wartość IDX w Domoticz* wartością z DOMOTICZ

  4. Zapisujemy ustawienia klikając MENU>ZAPISZ KONFIGURACJĘ

 

Tak spreparowane urządzenie możemy podłączyć pod sceny w systemie DOMOTICZ i wieczorami cieszyć się oświetleniem balkonu.