Come monitorare la bilancia di Xiaomi con Domoticz

La Xiaomi Mi Scale è la bilancia di Xiaomi con il Bluetooth (quindi per farla semplice potrete salvarvi i dati dove meglio preferite e farvi un grafico con i pesi misurati) che potete acquistare qui.

Con l’integrazione con Domoticz potrete gestirla come meglio preferite, eventualmente anche con HomeKit di Apple e l’emulazione del server con Homebridge.

Iniziamo!

sudo git clone https://github.com/marcotini/node-xiaomi-scale /home/pi/domoticz/scripts

Ora create un sensore virtuale che abbia uno switch (quindi un semplice bottone) e mettete come On Action:

script:///home/pi/domoticz/scripts/weight.sh

Vi serviranno anche 2 sensori virtuali per persona che usa la bilancia, uno per i KG e uno per il valore di BMI.

Adesso create lo script con sudo nano /home/pi/domoticz/scripts/weight.sh e incollate:

#!/bin/bash

before=$(head -1  /home/pi/domoticz/scripts/node-xiaomi-scale/scaleData.txt)

sudo /usr/bin/node /home/pi/domoticz/scripts/node-xiaomi-scale/fetchscaledata.js > /home/pi/domoticz/scripts/node-xiaomi-scale/scaleData.txt

kg=$(head -1  /home/pi/domoticz/scripts/node-xiaomi-scale/scaleData.txt)
bmi=$(tail -1 /home/pi/domoticz/scripts/node-xiaomi-scale/scaleData.txt)

maggiore=60
zero=0

if (( $(echo "$kg != $before" |bc -l) )); then
if (( $(echo "$kg > $maggiore" |bc -l) )); then

curl -s -k "http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=123&nvalue=0&svalue=$kg" > /dev/null
curl -s -k "http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=456&nvalue=0&svalue=$bmi" > /dev/null

elif (( $(echo "$kg > $zero" |bc -l) )); then

curl -s -k "http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=789&nvalue=0&svalue=$kg" > /dev/null
curl -s -k "http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=012&nvalue=0&svalue=$bmi" > /dev/null

fi
fi

Lo script è utile per due persone ma può essere allargato per quante preferite.
Gli IDX 123 e 456 si riferiscono ai KG e BMI della persona che pesa di più di 60 KG (come potrete notare dalla variabile maggiore è stato settato così, ma potete benissimo mettere quello che preferite in base alla vostra differenza di peso). 789 e 012 invece si riferiscono a quella che ha peso inferiore.

Inoltre lo script controlla che il valore non sia uguale al precedente (nel caso abbiate effettuato due letture consecutive).

NB: dovete aver installato sul vostro sistema Node JS.

Eventualmente potete anche creare l’automazione per far in modo che (ad esempio il Raspberry Pi) la bilancia venga interrogata la mattina, ad esempio alle 7, 8 o 9 di mattina (così da non dover ogni volta ripremere il tasto su Domoticz). Voi sapete che ogni giorno alle 7.00 di mattina la bilancia fornisce i dati, se ce ne sono: lo script li salva. Altrimenti no. Eseguite sudo crontab -e e incollate:

0 7 * * * /home/pi/domoticz/scripts/weight.sh
0 8 * * * /home/pi/domoticz/scripts/weight.sh
0 9 * * * /home/pi/domoticz/scripts/weight.sh

Come gestire e monitorare i consumi con Domoticz e la presa TP-Link HS100/HS110

Se non conoscete ancora la presa intelligente della TP-Link è ora di conoscerla… e acquistarla! Qui potete acquistare la HS100 che ha solo lo swtich on e off. Mentre qua per soli 5 euro in più potete acquistare quella con anche il monitoraggio della corrente.

Dovete prima di tutto creare un sensore virtuale che sia di tipo Wall socket. Inserite in on e off questi due (cambiate ovviamente gli IP).

Per il tasto on:

script:///home/pi/domoticz/scripts/tplink-smartplug.py -t 172.24.1.123 -c on

Per il tasto off:

script:///home/pi/domoticz/scripts/tplink-smartplug.py -t 172.24.1.123 -c off

Non premetelo ancora! Prima create lo script monitorare il consumo:

sudo nano /home/pi/domoticz/scripts/HS110.py

E incollate:

#!/usr/bin/env python
#
# TP-Link Wi-Fi Smart Plug Protocol Client
# For use with TP-Link HS110: energy monitor
#
# Gets current power (W) and cumulative energy (kWh)
# and sends to Domoticz
import socket
import argparse
import json
import urllib
import urllib2
# ip, port, and command for HS110
ip = '172.24.1.123'
port = 9999
cmd = '{"emeter":{"get_realtime":{}}}'
# Domoticz command stub and IDx of HS110
baseURL = 'http://127.1.1.1:8080/json.htm?type=command&param=udevice&nvalue=0'
HSIdx = 456
# Encryption and Decryption of TP-Link Smart Home Protocol
# XOR Autokey Cipher with starting key = 171
def encrypt(string):
key = 171
result = "\0\0\0\0"
for i in string:
a = key ^ ord(i)
key = a
result += chr(a)
return result
def decrypt(string):
key = 171
result = ""
for i in string:
a = key ^ ord(i)
key = ord(i)
result += chr(a)
return result
def domoticzrequest (url):
request = urllib2.Request(url)
#   request.add_header("Authorization", "Basic %s" % base64string)
response = urllib2.urlopen(request)
return None;
# Send command and receive reply
try:
sock_tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_tcp.connect((ip, port))
sock_tcp.send(encrypt(cmd))
data = sock_tcp.recv(2048)
sock_tcp.close()

#   print "Sent:     ", cmd
result = decrypt(data[4:])
jsonData = json.loads(result)
#   print "Received: "
#   print json.dumps(jsonData, indent=4, sort_keys=True)
power = jsonData['emeter']['get_realtime']['power']
total = jsonData['emeter']['get_realtime']['total'] * 1000
#   print power, total
except socket.error:
quit("Cound not connect to host " + ip + ":" + str(port))
# Send data to Domoticz
try:
url = baseURL + "&idx=%s&svalue=%s;%s" % (HSIdx, power, total)
domoticzrequest(url)
except urllib2.URLError, e:
print e.code

Create un altro sensore virtuale per monitorare il consumo:

Mentre questo sudo nano /home/pi/domoticz/scripts/tplink-smartplug.py incollate:

#!/usr/bin/env python
#
# TP-Link Wi-Fi Smart Plug Protocol Client
# For use with TP-Link HS-100 or HS-110
#
# by Lubomir Stroetmann
# Copyright 2016 softScheck GmbH
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
import socket
import argparse
version = 0.1
# Check if IP is valid
def validIP(ip):
try:
socket.inet_pton(socket.AF_INET, ip)
except socket.error:
parser.error("Invalid IP Address.")
return ip
# Predefined Smart Plug Commands
# For a full list of commands, consult tplink_commands.txt
commands = {'info'     : '{"system":{"get_sysinfo":{}}}',
'on'       : '{"system":{"set_relay_state":{"state":1}}}',
'off'      : '{"system":{"set_relay_state":{"state":0}}}',
'cloudinfo': '{"cnCloud":{"get_info":{}}}',
'wlanscan' : '{"netif":{"get_scaninfo":{"refresh":0}}}',
'time'     : '{"time":{"get_time":{}}}',
'schedule' : '{"schedule":{"get_rules":{}}}',
'countdown': '{"count_down":{"get_rules":{}}}',
'antitheft': '{"anti_theft":{"get_rules":{}}}',
'reboot'   : '{"system":{"reboot":{"delay":1}}}',
'reset'    : '{"system":{"reset":{"delay":1}}}'
}
# Encryption and Decryption of TP-Link Smart Home Protocol
# XOR Autokey Cipher with starting key = 171
def encrypt(string):
key = 171
result = "\0\0\0\0"
for i in string:
a = key ^ ord(i)
key = a
result += chr(a)
return result
def decrypt(string):
key = 171
result = ""
for i in string:
a = key ^ ord(i)
key = ord(i)
result += chr(a)
return result
# Parse commandline arguments
parser = argparse.ArgumentParser(description="TP-Link Wi-Fi Smart Plug Client v" + str(version))
parser.add_argument("-t", "--target", metavar="<ip>", required=True, help="Target IP Address", type=validIP)
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("-c", "--command", metavar="<command>", help="Preset command to send. Choices are: "+", ".join(commands), choices=commands)
group.add_argument("-j", "--json", metavar="<JSON string>", help="Full JSON string of command to send")
args = parser.parse_args()
# Set target IP, port and command to send
ip = args.target
port = 9999
if args.command is None:
cmd = args.json
else:
cmd = commands[args.command]
# Send command and receive reply
try:
sock_tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_tcp.connect((ip, port))
sock_tcp.send(encrypt(cmd))
data = sock_tcp.recv(2048)
sock_tcp.close()
print "Sent:     ", cmd
print "Received: ", decrypt(data[4:])
except socket.error:
quit("Cound not connect to host " + ip + ":" + str(port))

Ora potete impostare un’automazione che esegua lo script di controllo del consumo e che aggiorni l’IDX corrispettivo.

Per comodità ho messo come IP della presa 172.24.1.123 e come IDX 456 (cercateli nei due script e modificateli).

Se non volete creare l’automazione che controlli il consumo, semplicemente create un altro sensore virtuale che al tasto on abbia come parametro:

script:///home/pi/domoticz/scripts/HS110.py

Abbastanza semplice no?

Dopo che avrete monitorato i consumi per qualche mese avrete a disposizione un bel grafico su cui poter lavorare:

Come monitorare la temperatura della CPU con Domoticz

Se volete controllare la temperatura della CPU del vostro Raspberry Pi e avere un grafico riportato nel vostro pannello Domoticz, vi basterà usare questo script:

sudo nano /home/pi/domoticz/scripts/cputemp.sh

E incollare (cambiate 123 in base all’IDX del sensore che avete su Domoticz)

#!/bin/bash

milcel=$(cat /sys/class/thermal/thermal_zone0/temp)

MEMUSG=`echo "scale=3;$milcel/1000" | bc`

curl -s -k "http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=123&nvalue=0&svalue=$MEMUSG" > /dev/null

Ora aggiungete a sudo crontab -e questo (controllerà ogni 5 minuti la temperatura, salvandovela nel sensore virtuale e facendovi poi un grafico):

5 * * * * /home/pi/domoticz/scripts/cputemp.sh

Come creare un sensore virtuale su Domoticz

Se volete creare un sensore virtuale per monitorare delle risorse che possono essere la temperatura della CPU, piuttosto che un bottone o tasto che esegue qualche script/applicativo, vi basterà aprire Domoticz e andare su HARDWARE. Selezionate Dummy (Does nothings, use for virtual switches only):

E dategli il nome che preferite (anche Dummy va bene). Ora cliccate su CREATE VIRTUAL SENSOR alla riga Dummy e aggiungete quello che preferite, ad esempio uno di temperatura:

Adesso spostatevi su DEVICE e segnatevi l’IDX che potrà servirvi per accedervi. Potrete semplicemente aggiornare il dato facendo una chiamata tipo (presupponendo IDX=123 e valore da aggiornare 99):

http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=123&nvalue=0&svalue=99</>

Semplice no?

Come tenere Domoticz sempre attivo

Dato che molto spesso tra sensori vari o thread aperti da plugin non troppo funzionanti Domoticz può smettere di funzionare da un punto all’altro, il mio suggerimento è quello di crearvi uno script gestito dal crontab e fare in modo che controlli ogni minuto se è attivo. E nel caso, lo riattivi. Presupponendo che l’abbiate installato nella home del vostro Raspberry Pi (nel caso cambiate semplicemente path):

sudo nano /home/pi/domoticz/scripts/checkdomoticz.sh

Incollate:

#!/bin/bash

ip=127.0.0.1
port=8080
idx=1

function jsonValue() {
KEY=$1
num=$2
awk -F"[,:}]" '{for(i=1;i<=NF;i++){if($i~/'$KEY'\042/){print $(i+1)}}}' | tr -d '"' | sed -n ${num}p
}

DOMOTICZ=`curl -s --connect-timeout 2 --max-time 5 "http://$ip:$port/json.htm?type=devices&rid=$idx"`
STATUS=$(echo $DOMOTICZ | jsonValue status 1)
OK="OK"

echo "Domoticz status = $STATUS"

if [ "$STATUS" == "" ] ; then

echo Domoticz status NOK1, retrying in 5 seconds...
sleep 5
DOMOTICZ=`curl -s --connect-timeout 2 --max-time 5 "http://$ip:$port/json.htm?type=devices&rid=$idx"`
STATUS2=$(echo $DOMOTICZ | jsonValue status 1)
echo Domoticz status = $STATUS2

if [ "$STATUS2" == "" ] ; then
echo Domoticz status NOK2, retrying in 5 seconds...
sleep 5
DOMOTICZ=`curl -s --connect-timeout 2 --max-time 5 "http://$ip:$port/json.htm?type=devices&rid=$idx"`
STATUS3=$(echo $DOMOTICZ | jsonValue status 1)
echo Domoticz status = $STATUS3

if [ "$STATUS3" == "" ] ; then
echo Domoticz status NOK3, stopping service, killing process, starting service...
sudo service domoticz stop
sleep 5
sudo service domoticz start
fi
fi
fi

Ora eseguite: sudo crontab -e

E aggiungete in fondo:

* * * * * /home/pi/domoticz/scripts/checkdomoticz.sh

Questo controllerà ogni minuto se è attivo, così male che vada (e nel caso non ci siano ovviamente problemi gravi) Domoticz vi rimarrà disattivato al massimo per 1 minuto.

Come configurare Monit con Domoticz

sudo nano /etc/monit/conf.d/domoticz

Copiate e incollate:

check process domoticz with pidfile /var/run/domoticz.pid
start program = "/etc/init.d/domoticz.sh start"
stop  program = "/etc/init.d/domoticz.sh stop"
if failed
url http://127.0.0.1:8080/json.htm?type=command&param=getversion
and content = '"status" : "OK"'
for 2 cycles
then restart
if 5 restarts within 5 cycles then exec "/sbin/reboot"

E poi riavviate Monit con:

sudo monit reload

Come configurare Monit con Plex

sudo nano /etc/monit/conf.d/plex

Incollate questo (modificando le porte nel caso vi servissero, ma la 32400 dovrebbe andar bene):

check process Plex with pidfile "/var/lib/plexmediaserver/Library/Application\ Support/Plex\ Media\ Server/plexmediaserver.pid"
    start program = "/usr/sbin/service plexmediaserver start" with timeout 60 seconds
    stop program  = "/usr/sbin/service plexmediaserver stop"
    if failed host 127.0.0.1 port 32400 with timeout 30 seconds for 5 cycles then restart
    #if failed port 32401 with timeout 30 seconds for 5 cycles then restart
    #if failed port 32469 with timeout 30 seconds for 5 cycles then restart
    #if failed port 1909 with timeout 30 seconds for 5 cycles then restart
    #if failed url http://127.0.0.1:32400/web/index.html with timeout 30 seconds for 5 cycles then restart

E poi riavviate Monit con:

sudo monit reload

Come configurare Monit con Transmission

sudo /etc/monit/conf.d/transmission

Copiate e incollate:

check process Transmission matching "transmission-daemon"
    start program = "/etc/init.d/transmission-daemon start"
    stop program  = "/etc/init.d/transmission-daemon stop"
    if failed host 127.0.0.1 port 9091 type TCP for 2 cycles then restart
    if 2 restarts within 3 cycles then unmonitor

E poi riavviate Monit con:

sudo monit reload

Come configurare Monit con Samba

Se avete precedentemente installato Monit e avete capito le sue infinite possibilità e volete monitorare il vostro server SMB, ecco come configurarlo perché controlli e nel caso riavvii Samba:

sudo nano /etc/monit/conf.d/smbmonitor

E incollate:

check process Samba with pidfile "/var/run/samba/smbd.pid"
start program = "/etc/init.d/smbd start"
stop program = "/etc/init.d/smbd stop"
if failed host 127.0.0.1 port 139 type tcp for 2 cycles then restart
if 2 restarts within 3 cycles then unmonitor

Poi riavviate Monit con sudo monit reload e andate da browser alla porta 2812 (nel caso non l’abbiate cambiata).

Come gestire cartelle con apostrofi

Nel caso la vostra cartella abbia un apostrofo, il terminale bash (o quello che sia) potrebbe riscontrarvi qualche errore.

Mettete tutto tra parentesi, ad esempio: cd '/cartella(con)/anche/parentesi' per entrare dentro quella cartella.

Come convertire una macchina virtuale da VMware a VirtualBox

Importare una macchina virtuale da VMware a VirtuaBox è un po’ più difficile perché bisognerà riconfigurare tutte le caratteristiche della macchina.

Prima di tutto aprite la cartella in cui è contenuta la macchina virtuale che volete esportare. Di solito dovrebbe essere dentro Documenti, Macchine virtuali. Cliccate con il tasto destro e poi su Mostra contenuto pacchetto. Ora identificate i file i file vmdk e copiateli tutti sul Desktop dentro una cartella.

Ora andate su VirtualBox, configurate una nuova macchina, seguite i passaggi e riconfigurate come quella su VMware. Quando vi verrà chiesto l’Hard disk, spuntate la voce Use existing hard disk e selezionate il primo file .vmdk che avete copiato (sarà quello senza numero identificativo). Andate avanti con la procedura e avviate la macchina!

Semplice no?

Come convertire una macchina virtuale da VirtualBox a VMware

Aprite VirtualBox, selezionate la macchina virtuale e su File in alto, cliccate su Esporta applicazione virtuale, selezionate il formato ova. Salvate e aspettate che finisca il processo.

Ora aprite VMware e cliccate in alto su Archivio e poi su Importa....

Selezionate il file .ova appena creato e andate avanti con i passaggi. Attendete l’importazione e via!

Come provare a difendersi da un attacco DDoS

Parto con un po’ di presupposti perché ovviamente l’argomento è molto vasto e non sarebbe affrontabile in un semplice articolo. I comandi che andrò ad elencarvi dipendono ovviamente da cosa state subendo e sopratutto se avete accesso al vostro server. Ma tenendo conto che avete accesso ma semplicemente siete inondati di richieste, di traffico flood o altre prove di connessioni, richieste di login o comunque qualcosa sulle porte o sulle connessioni, ecco quanto.

Per visualizzare le connessioni in ingresso:

sudo netstat -plan|grep :80|awk {'print $5'}|cut -d: -f 1|sort|uniq -c|sort -nk 1

Nel caso avete https e la porta 443:

sudo netstat -plan|grep :443|awk {'print $5'}|cut -d: -f 1|sort|uniq -c|sort -nk 1

Visualizzare l’elenco completo dell’iptables:

sudo iptables -L --line-numbers

Se volete cancellare ad esempio la seconda regola fate così:

sudo iptables -D INPUT 2

Oppure se volete impostare un limite alle richieste:

sudo iptables -A INPUT -p tcp --syn -m limit --limit 5/s --limit-burst 10 -j DROP

Nel caso anche questo:

sudo iptables -A INPUT -p tcp --tcp-flags SYN,ACK,FIN,RST SYN -m limit --limit 1/s -j DROP

Mentre se in tutto questo avete notato che c’è qualche IP che vi fa migliaia di richieste, ecco come impedirglielo:

iptables -A INPUT -s 8.8.8.8 -j DROP

Le regole nell’iptables vengono a ogni riavvio resettate, quindi se volete salvarle dovete specificarlo.

Come installare nginx su Raspberry Pi

Prima di tutto dovete fare una cosa importantissima, rimuovete Apache:

sudo apt-get remove apache2

Ora che l’avete rimosso e potete iniziare a divertirvi seriamente, installate nginx:

sudo apt-get install nginx

Finito. Ecco sì, finito! Avrà già configurato la cartella che usavate in precedenza e tutto quanto dovrebbe funzionarvi alla perfezione (ovviamente meglio di prima).

Nel caso, configurate quel che vi manca da qua:

sudo nano /etc/nginx/sites-available/default

Posso garantirvi personalmente, che non sentirete la mancanza. E anzi, vi domanderete perché non l’avete fatto prima!

Come disabilitare IPv6 su Avahi

Come è ben noto IPv6 non è implementato praticamente da nessuna parte (ancora) e nelle reti pubbliche viene impacchettato nella versione 4.

Spesso da più problemi che altro… quindi, perché non disattivarlo?

sudo nano /etc/avahi/avahi-daemon.conf

E alla riga use-ipv6=yes mettete un bel no.

Per gli altri parametri: http://manpages.ubuntu.com/manpages/zesty/man5/avahi-daemon.conf.5.html

Come gestire Homebridge con systemd

Se volete gestire Homebridge come servizio e far si che a ogni riavvio venga gestito direttamente dal sistema operativo, senza il supporto di screen come vi avevo fatto vedere qua, seguite questa semplice guida!

Prima di tutto trovate il percorso di Homebridge con:

which homebridge

Poi modificate sudo nano /etc/default/homebridge e incollate:

# Defaults / Configuration options for homebridge
# The following settings tells homebridge where to find the config.json file and where to persist the data (i.e. pairing and others)
HOMEBRIDGE_OPTS=-U /var/homebridge

# If you uncomment the following line, homebridge will log more 
# You can display this via systemd's journalctl: journalctl -f -u homebridge
# DEBUG=*

Poi sudo nano /etc/systemd/system/homebridge.service e incollate (cambiando ad ExecStart il percorso che avete trovato precedentemente con il which:

[Unit]
Description=Node.js HomeKit Server 
After=syslog.target network-online.target

[Service]
Type=simple
User=homebridge
EnvironmentFile=/etc/default/homebridge
ExecStart=/usr/local/bin/homebridge $HOMEBRIDGE_OPTS
Restart=on-failure
RestartSec=10
KillMode=process

[Install]
WantedBy=multi-user.target

Ora create un utente: sudo useradd --system homebridge, create le cartelle con i permessi giusti e abilitate il servizio:

sudo mkdir /var/homebridge
sudo cp ~/.homebridge/config.json /var/homebridge/
sudo cp -r ~/.homebridge/persist /var/homebridge
sudo chmod -R 0777 /var/homebridge
sudo systemctl daemon-reload
sudo systemctl enable homebridge
sudo service homebridge start

E controllate se funziona con: sudo service homebridge status.

Fonte: https://timleland.com/setup-homebridge-to-start-on-bootup/