CiaoBitHome v1.0 + NodeMcu + OpenHab

Il progetto CiaoBitHome v1.0, la domotica fai da te:

In questo articolo presentiamo un progetto 100% targato Ciaobit.com che permette di creare un punto di partenza per la domotica fai da te, basata 100% su sistemi open source.

Il progetto è composto da diverse componenti software e hardware.
Nell’articolo è possibile trovare tutto il necessario per realizzare un prototipo funzionante.

Scarica CiaoBitHome v1.0

 

Le funzionalità implementate in questa versione: CiaoBitHome v1.0

• WIFI: Connessione protetta da username e password
• MQTT: Connessione a broker MQTT attraverso l’inserimento di: Nome dispositivo, Username, Password, indirizzo ip e porta
• RF TX: Possibilità di spedire comandi radio ad apricancelli/apriporta in modulazione ASK simulando un chip PT2262 (va configurata la durata degli impulsi in base alla frequenza del modulo RF applicato, es 433Mhz..315Mhz..)
• LED DIMMER: Possibilità di regolare l’intensità luminosa di una barra a led alimentata a 12v attraverso un Mosfet
• TEMPERATURA E UMIDITA’: Possibilità di rilevare la temperatura e l’umidità della stanza mediante il collegamento ad un modulo DHT22
• SENSORE PIR: Permette di connettere un sensore di movimento ad infrarossi PIR (ad esempio hc-sr501) per rilevare la presenza o intrusioni.

 

Hardware NodeMcu:

Il progetto si basa su una componente hardware che si occupa di

• rilevare delle misure o degli stati
• interagire con il monto esterno attraverso attuazione.

CiaoBitHome v1.0 serve per l’appunto a gestire queste funzionalità avvalendosi dell’hardware NodeMcu.
Per approfondimenti puoi vedere anche: Cos’è l’Esp8266 e il modulo NodeMcu

Vediamo nel dettaglio i vari moduli:

Alimentazione:

Il chip Esp8266 che è montato sul NodeMcu, lavora ed è alimentato a 3.3v.
Bisogna quindi fare molta attenzione a non inviare segnali con logica a 5v, potremmo bruciare il chip!

Il NodeMcu mette a disposizione un regolatore di tensione che prende in input una tensione che va da 4,75 a 20v. Tuttavia è consigliata un’alimentazione tra 5v e 10v. Ho ritenuto opportuno quindi non stressare il regolatore lm1117 con una tensione eccessiva, e ho inserito un regolatore lm7805 che abbassa la tensione a 5v. Lo schema è semplicissimo, al regolatore si aggiungono solo 2 condensatori.

Modulo WIFI:

Il WIFI è gestito interamente dal chip Esp8266, non è richiesto hardware esterno.

Modulo trasmissione RF:

Questi moduli costano molto poco perchè sono piuttosto semplici da realizzare.
sono alimentabili da 3 a 12V, questo li rende molto versatili. La velocità massima di trasmissione è di circa 10Kbps e la distanza massima solitamente è di massimo 90m in campo aperto e alimentandoli a 12v.
La modulazione utilizzata è ASK (Amplitude-Shift Keying) ovverouna modulazione dell’ampiezza della portante.
In pratica abbiamo una frequenza portante che viene trasmessa quando abilitiamo la trasmissione.
Per i meno esperti, possiamo immaginarla come un telegrafo che trasmette codice morse, “finchè premi il bottone, si trasmette un suono”.
Questi modulo RF hanno 3 pin, due di alimentazione e uno per la trasmissione.

in questo progetto l’alimentazione può avvenire dai 3v del regolatore, ma ho preferito utilizzare i 5v per guadagnare un pò più portata e per sgravare il regolatore del NodeMcu.
Il pin del modulo radio che permette la trasmissione è stato collegato alla porta GPIO D0 del NodeMcu.

DHT22, Sensore di temperatura e umidità:

Questo sensore è molto semplice da interfacciare, il NodeMcu mette a disposizione dei metodi che ne facilitano l’implementazione.

Anche qui abbiamo 3 pin. Come si vede in figura, il primo e l’ultimo pin sono utilizzati per alimentare il DHT22.
Il DHT22 gestisce sia a 5v che 3.3v, nel nostro caso utilizzeremo i 3.3v forniti dal NodeMcu.
Il secondo pin è quello che permette la comunicazione tra NodeMcu e il DHT22 e va connesso al pin D7 del NodeMcu .
La comunicazione è bidirezionale e sullo stesso filo.

Se vuoi approfondire il funzionamento del DHT22 ti suggeriamo di vedere questo articolo: DHT22 (am2302) : Sensore di umidità e temperatura

Mosfet di potenza per pilotare le barre a led:

Il NodeMcu non può gestire attraverso le porte del processore, in modo diretto, l’accensione di una barra a led a 12v per due modivi:

• La corrente è troppo alta (1m di barra a led che contiene 72 chip 5630 consuma circa 18W, quindi circa 1.5A a 12v)
• la tensione è troppo bassa (le barre a led lavorano a 12v)

Per ovviare a questo problema possiamo usare diverse soluzioni come ad esempio i vecchi e rumorosi relè o i nuovi relè allo stato solido, che, opportunamente selezionati, ci permette di accender e spegnere la barra a led.
Il buon vecchio relè elettromecanico ha un vantaggio, quello di isolare il circuito del NodeMcu da quello con tensione più alta in quanto le componenti del relè sono fisicamente separate.
Se vogliamo però dimmare agilmente la luce, ovvero di poter decidere l’intensità luminosa dei led, possiamo intraprendere un’altra strada, usare un componente elettonico chiamato mostef.

Il Mosfet, il Dimmer e il PWM:
Il Mosfet ha una velocità di commutazione (da “acceso” a “spento”) abbastanza alta da evitare che l’occhio se ne accorga e si stanchi; inoltre è silenzioso perchè non ha parti elettromeccaniche in movimento.
Per manipolare l’intensità luminosa, usiamo una modulazione della larghezza di un impulso, detto in inglese PWM (Pulse-Width Modulation).

Per capire come agisce il PWM, immaginiamo di divedere un’ unità temporale di un secondo in 1000 frammenti temporali, chiamiamo questo valore frequenza del PWM.
Ora immaginiamo che questo millesimo di secondo venga suddiviso ancora in 1024 frammenti temporali, questa ulteriore suddivisione si chiama risoluzione del PWM. La risoluzione del NodeMcu è di 10 bit, quindi 2^10 = 1024
Ora immaginiamo che questi 1024 elementi possano avere uno stato di ON o OFF.
Se teniamo tutti i 1024 slot temporali attivi, la potenza di output sarà al 100%, se ne accendiamo solo i primi 512 slot, avremo un’intensità luminosa del 50%, se non abbiamo alcun slot attivo, l’intensità luminosa sarà pari a 0%.

Usiamo quindi il Mosfet per accendere e spegnere la barra a led molto velocemente, più precisamente 1000 volte al secondo.

Il Mosfet ha 3 pin, come da immagine, da sinistra verso destra: Gate, Drain, Source.

• Il Gate va connesso al pin D2 del NodeMcu
• Il Drain va a valle della barra  a led (i 12v dell’alimentatore entrano nella barra a led e il polo negativo dei led va connesso al Drain del Mosfet)
• Il Source va connesso a massa

 

Sensore di movimento a infrarossi PIR:

Il modulo HC-SR501 è un modulo che permette di rilevare i movimenti attraverso una tecnologia all’infrarosso.
Il modulo da la possibilità al NodeMcu di inviare questa informazione all’OpenHab dove è possibile creare delle regole che gestiscono questo evento, dando la possibilità di spaziare dal mero rilevamento di presenza, all’accensione automatica della lampada a led, ma anche un piccolo sistema anti intrusione.

Il modulo HC-SR501 ha 3 pin, l’alimentazione (che va da 5 a 20V), la massa e l’output a 3.3v. L’output va connesso al pin D1 del NodeMcu.
Possiamo decidere di alimentare a 5V il dispositivo collegando l’alimentazione sull’uscita dell’LM7805.
Se vogliamo invece usare l’alimentazione a 3.3v, bisogna bypassare il regolatore di tensione che il modulo HC-SR501 possiede integrato.
Per alimentare in modo diretto a 3.3v il modulo, basta collegarsi sul pin in alto a destra, appena sotto al Jumper giallo che si vede in figura qui sotto:

Come si vede in figura, sono presenti due potenziometri che permettono di regolare:

• Potenziometro a destra: Gestisce il tempo, è possibile impostare un valore da 3 a 300 secondi
  
• Potenziometro di sinistra: Regola la sensitività del sensore che va da 3 a 7 metri.
  

Infine in alto a destra ci sono 3 piedini che assieme ad un jumper (ponticello di colore giallo che si vede in alto a destra del circuito) permette di decidere la modalità di funzionamento del circuito

• Con il jumper che collega i primi 2 piedini: l’allarme non è ripetibile, il segnale di output rimane alto finchè non passa il tempo definito dal potenziometro
• Con il jumper che collega il secondo e il terzo piedino: “l’allarme” si autoresetta ed è ripetibile

nel nostro caso il jumper va rimosso

Software NodeMcu:

Come già accennato CiaoBitHome utilizza la connessione Wifi per la comunicazione tra OpenHab e il NodeMCU. Il protocollo che permette la comunicazione tra i diversi attori è l’MQTT.

Il Protocollo MQTT infatti (MQ Telemetry Transport) è un protocollo molto leggero che permette di comunicare tra dispositivi diversi senza grossi dispendi di banda. Il funzionamento del protocollo è simile a quello di una chat. I clients, ovvero “gli utenti della chat”, sono  i dispositivi NodeMcu e una componente di OpenHab. I clients si collegano al broker MQTT che è un servizio server installato anche sullo stesso server dove è presente OpenHab. Il broker quindi gestisce l’instradamento dei messaggi tra i vari cients.
L’MQTT mette a disposizione anche la possibilità di identificare (attraverso un nome) e autenticare (attraverso username e password) i clients che si connettono.

Torniamo allo script del progetto CiaoBitHome.
Lo script va tutto nel file init.lua
Il file init.lua è quello che viene lanciato in automatico dal NodeMcu all’avvio.

-- CiaoBitHome v0.1 (Author: Matteo Dalle Feste - matteo@dallefeste.com - info@ciaobit.com - https://ciaobit.com )
-- Libero utilizzo a fini non commerciali e mantenendo i crediti dell'autore
-- You can use this script for free. Not for commercial use. Keep author credits

-- Mappatura pin GPIO / Pin Mapping
-- D0 = GPIO Modulo RF
-- D1 = GPIO 5 Sensore PIR
-- D2 = GPIO 4 Mosfet PWM (striscia led)
-- D3 = GPIO 0 Output
-- D4 = GPIO 2 Output
-- D5 = GPIO 14 Output
-- D6 = GPIO 12 Output
-- D7 = GPIO 13 DHT22
-- D8 = GPIO 15
-- RX = GPIO 3
-- TX = GPIO 1


print("Starting Module in 3 seconds..")
tmr.delay(3000)

-- -------- CONFIGURAZIONE WIFI / WIFI CONFIG -----------------
wifi.setmode(wifi.STATION)
wifi.sta.config("CASA","passwifi12345")

-- --------- CONFIGURAZIONE MQTT / MQTT CONFIG -------------------
 MqttConfig={}
 MqttConfig.Broker="192.168.123.230"
 MqttConfig.Port=1883
 MqttConfig.Secure=0
 
 MqttConfig.User="user"
 MqttConfig.Pass="pass"
 MqttConfig.DeviceName="Sala"

-- --------- RF CODICI E TEMPI / RF CODES AND TIMINGS ----------
RFCode ={ {2,2,2,2,2,2,2,1,0,0,0},{2,2,2,2,2,2,2,0,1,0,0}, {2,2,2,2,2,2,2,0,0,1,0}, {2,2,2,2,2,2,2,0,0,0,1}}

RFDurationLong = 381
RFDurationShort = 127
RFDurationSync = 4063

-- ------- STATUS CONNESSIONI / CONNECTIONS STATUS ------------------
Mqtt_StatusConnected=0
Wifi_StatusConnected=0

-- ------- SETUP DELLE PORTE GPIO / SETUP GPIO PORTS --------------
 
-- GPIO 0 OUTPUT FOR RF MODULE
gpio.mode(0,gpio.OUTPUT) 
gpio.write(0,gpio.LOW) 

-- GPIO 1 INTERRUPT PIR SENSOR
gpio.mode(1,gpio.INT,gpio.PULLUP)


-- GPIO 2 AS PWM OUTPUT (MOSFET) 1Khz
pwm.setup(2, 1000, 1023)
pwm.setduty(2, 0)
pwm.start(2)

-- GPIO 3,4,5,6 AS DIGITAL OUTPUT 
 gpio.mode(3,gpio.OUTPUT) 
 gpio.write(3,gpio.LOW) 

 gpio.mode(4,gpio.OUTPUT) 
 gpio.write(4,gpio.LOW) 

 gpio.mode(5,gpio.OUTPUT) 
 gpio.write(5,gpio.LOW) 

 gpio.mode(6,gpio.OUTPUT) 
 gpio.write(6,gpio.LOW) 
 
 
 -- ------------- INTERRUPT EVENTO PIR / PIR INTERRUPT EVENT ----------------------
 function pirEvent2()
  		if gpio.read(1) == 1 then
  			print("PIR: Motion detected") 
 			if Mqtt_StatusConnected  ==1 then
 				m:publish("/" .. MqttConfig.DeviceName .. "/ch1/state","ON",0,0)
 			end
 		else
			print("PIR: NO Motion detected")
			if Mqtt_StatusConnected  ==1 then
	 			m:publish("/" .. MqttConfig.DeviceName .. "/ch1/state","OFF",0,0)
	 		end 
	 	end
 end
gpio.trig(1, "both",pirEvent2)

-- CONFIGURAZIONE CLIENT MQTT / CONFIGURING MQTT CLIENT --------------------------------
 m = mqtt.Client(MqttConfig.DeviceName, 180, MqttConfig.User, MqttConfig.Pass) 
 m:lwt("/lwt", "offline", 0, 0) 
 m:on("offline", function(con) 
 	Mqtt_StatusConnected = 0
 	-- avvio riconnessione
 	tmr.start(1)
 end)
 
 m:on("connect",function(m) 
 		print("Mqtt: Connected to " .. MqttConfig.Broker) 
 		Mqtt_StatusConnected = 1
		 tmr.stop(1)
 		 m:subscribe("/" .. MqttConfig.DeviceName .. "/#",0, function(conn) 
 			print("Mqtt: Subscribed to ".. MqttConfig.DeviceName .. " feed") 
 		end)
		tmr.start(2)
	end )


tmr.register(1, 10000, 1, function() 
	reconnectMQTT()
 end)


 -- MQTT QUANDO ARRIVA UN MESSAGGIO / ON MESSAGE RECEIVE 
 m:on("message", function(conn, topic, data) 
 	print("Mqtt: Recieved " .. topic .. ":" .. data) 
 
 	if (topic=="/" .. MqttConfig.DeviceName .. "/ch0/com") then 
		data = tonumber(data)
		if  data ~= nil  and data > 0 then
				RFsendCommand(0,RFCode[data-1])
		end
 	elseif (topic=="/" .. MqttConfig.DeviceName .. "/ch2/com") then 
		setPWM(2,data)
	elseif (data=="ON") and (topic=="/" .. MqttConfig.DeviceName .. "/ch3/com") then 
		turnOn(3)
 	elseif (data=="OFF") and (topic=="/" .. MqttConfig.DeviceName .. "/ch3/com") then 
		turnOff(3)
 	elseif (data=="ON") and (topic=="/" .. MqttConfig.DeviceName .. "/ch4/com") then 
		turnOn(4) 
 	elseif (data=="OFF") and (topic=="/" .. MqttConfig.DeviceName .. "/ch4/com") then 
		turnOff(4)
 	elseif (data=="ON") and (topic=="/" .. MqttConfig.DeviceName .. "/ch5/com") then 
		turnOn(5)
 	elseif (data=="OFF") and (topic=="/" .. MqttConfig.DeviceName .. "/ch5/com") then 
		turnOff(5)
 	elseif (data=="ON") and (topic=="/" .. MqttConfig.DeviceName .. "/ch6/com") then 
		turnOn(6)
 	elseif (data=="OFF") and (topic=="/" .. MqttConfig.DeviceName .. "/ch6/com") then 
		turnOff(6)
 	end
 end) 
 
-- ------------- FUNZIONI ON OFF GPIO / FUNCTIONS ---------------------------------
 function turnOn(pin)
  		print("GPIO: Enabling Output " .. pin) 
 		gpio.write(pin,gpio.HIGH) 
 		m:publish("/" .. MqttConfig.DeviceName .. "/ch" .. pin .. "/state","ON",0,0) 
 end
 
 function turnOff(pin)
  		print("GPIO: Disabling Output " .. pin) 
 		gpio.write(pin,gpio.LOW) 
 		m:publish("/" .. MqttConfig.DeviceName .. "/ch" .. pin .. "/state","OFF",0,0) 
 end 

-- ------------- FUNZIONI PWM / FUNCTIONS --------------------------------- 
 function setPWM(pin,data)
  		print("PWM: Setting pin " .. pin .. " PWM to " .. data) 
 		 data = tonumber(data)
 		 curpwm = pwm.getduty(pin)
 		 if curpwm >= data then
	 		 for i = curpwm, data, -1 do
			   pwm.setduty(pin, i)
			   tmr.delay(100)
			   tmr.wdclr()
			end
 		else
 	 		 for i = curpwm, data, 1 do
			   pwm.setduty(pin, i)
			   tmr.delay(100)
			   tmr.wdclr()
			end
 		end		
 		m:publish("/" .. MqttConfig.DeviceName .. "/ch" .. pin .. "/state",data,0,0) 
 end 
 
 
 
-- INVIO TEMPERATURA E UMIDITA OGNI 300 SECONDI / SEND TEMPERATURE AND HUMIDITY EVERY 300Secs
tmr.register(2, 300000, tmr.ALARM_AUTO, function() 
 	if Wifi_StatusConnected == 1 and Mqtt_StatusConnected == 1 then
 		 sendTempHumid(7)
 	 end
 end) 
 
 
 function sendTempHumid(pin)
		status,temp,humi,temp_decimial,humi_decimial = dht.readxx(pin)
		if( status == dht.OK ) then
		   m:publish("/" .. MqttConfig.DeviceName .. "/temp" .. pin .. "/state", temp.."."..temp_decimial,0,0) 
		   m:publish("/" .. MqttConfig.DeviceName .. "/humid" .. pin .. "/state",humi.."."..humi_decimial,0,0) 
		elseif( status == dht.ERROR_CHECKSUM ) then
		  print( "DHT: Checksum error." );
		elseif( status == dht.ERROR_TIMEOUT ) then
		  print( "DHT: Time out." );
		end
 end
 
 -- ------------------ FUNZIONI RF / FUNCTIONS ----------------------------------------------
 function RFsendCommand(pin, data)
	 for r=0, 5 do
		 for i=0, #data do
			RFsendBit(pin,data[i])
		 end
		 RFookPulse(pin,RFDurationShort,RFDurationSync)
	  end
	  m:publish("/" .. MqttConfig.DeviceName .. "/ch" .. pin .. "/state","0",0,0) 
 end
 
 function RFsendBit(pin, bit)
	if bit ==1 then
	    RFookPulse(pin,RFDurationLong,RFDurationShort)
	    RFookPulse(pin,RFDurationLong,RFDurationShort)
	elseif bit == 0 then
	    RFookPulse(pin,RFDurationShort,RFDurationLong)
	    RFookPulse(pin,RFDurationShort,RFDurationLong)
	else
	     RFookPulse(pin,RFDurationShort,RFDurationLong)
	     RFookPulse(pin,RFDurationLong,RFDurationShort)
	end
 end
 
 function RFookPulse(pin, Ton, Toff)
 	gpio.write(pin,gpio.HIGH)
 	tmr.delay(Ton)
 	gpio.write(pin,gpio.LOW)
 	tmr.delay(Toff)
 end

 function reconnectMQTT()
 	print('MQTT: Connecting to Broker...')
	if m:connect(MqttConfig.Broker, MqttConfig.Port, MqttConfig.Secure, 1) then

	else
		Mqtt_StatusConnected = 0
	end
 end
 
wifi.sta.eventMonReg(wifi.STA_CONNECTING, function() 
	print("WIFI: Connecting")
end)

wifi.sta.eventMonReg(wifi.STA_APNOTFOUND, function()
	print("WIFI: Access point not Found")
	Wifi_StatusConnected = 0
 	Mqtt_StatusConnected = 0
end)

wifi.sta.eventMonReg(wifi.STA_GOTIP, function() 
	print("WIFI: Ip Address acquired") 
	print(wifi.sta.getip())
	print("WIFI: Connected")
	Wifi_StatusConnected = 1
 	-- avvio riconnessione
 	tmr.start(1)
end)
 
wifi.sta.eventMonStart()

Andiamo a personalizzare alcuni parametri dello script come:

• WIFI: va messo SSID e Password della propria rete Wireless

  
  -- -------- CONFIGURAZIONE WIFI / WIFI CONFIG -----------------
  wifi.setmode(wifi.STATION)
  wifi.sta.config("CASA","WifiPassword")
  

• MQTT: Indirizzo Ip e porta del broker. Inoltre va impostata l’identità del chip attraverso Username, Password e Nome del chip

  
  -- --------- CONFIGURAZIONE MQTT / MQTT CONFIG -------------------
   MqttConfig={}
   MqttConfig.Broker="192.168.123.230"
   MqttConfig.Port=1883
   MqttConfig.Secure=0
   
   MqttConfig.User="user"
   MqttConfig.Pass="pass"
   MqttConfig.DeviceName="Sala"
  

• RF: attualmente sono stati predisposti i codici di 4 bottoni. Inoltre sono stati impostati i tempi per lavorare con moduli RF ASK alla frequenza di 315Mhz. Se si vuole usare un modulo a 433Mhz va impostato un tempo diverso per le durate degli impulsi.

  
  -- --------- RF CODICI E TEMPI / RF CODES AND TIMINGS ----------
  RFCode ={ {2,2,2,2,2,2,2,1,0,0,0},{2,2,2,2,2,2,2,0,1,0,0}, {2,2,2,2,2,2,2,0,0,1,0}, {2,2,2,2,2,2,2,0,0,0,1}}
  
  RFDurationLong = 381
  RFDurationShort = 127
  RFDurationSync = 4063
  

Carichiamo quindi il file init.lua sul nostro NodeMcu (Esp8266) e riavviamolo attraverso un reset.
Se è tutto corretto, dalla console seriale vedremo una cosa simile a questa:

Starting Module in 3 seconds..
WIFI: Connecting
WIFI: Ip Address acquired
192.168.123.1	255.255.255.0	192.168.123.254
WIFI: Connected
MQTT: Connecting to Broker...
Mqtt: Connected to 192.168.123.230
Mqtt: Subscribed to Sala feed

Se abbiamo collegato il sensore PIR e siamo nel raggio d’azione, potremmo già ricevere alcuni messaggi di rilevamento presenza.

PIR: Motion detected
PIR: NO Motion detected
Mqtt: Recieved /Sala/ch1/state:ON
Mqtt: Recieved /Sala/ch1/state:OFF
Mqtt: Recieved /Sala/ch2/com:768
PWM: Setting pin 2 PWM to 768
Mqtt: Recieved /Sala/temp7/state:20.600
Mqtt: Recieved /Sala/humid7/state:38.500

Come si può vedere il modulo ha rivelato dei movimenti, ha eseguito la richiesta di modifica del valore del PWM e in fine ha inviato al Broker i valori di temperatura e umidità attraverso il protocollo MQTT.

 

Software OpenHab:

Veniamo ora alla configurazione di OpenHab. Dobbiamo configurare:

Gli items:
Gli Items descrivono la natura degli elementi che andiamo a collegare.
Inseriamo il file mqtt.items nella cartella dedicata alle rules in OpenHab, nel mio caso: /opt/openhab2/conf/items/

Group Sala

// LED Dimmer
String mqttCh2 "Dimmer [%d %%]"  (Sala) {mqtt=">[localbroker:/Sala/ch2/com:command:*:default]"}


// Modulo RF
String Rf "RF" (Sala) {mqtt=">[localbroker:/Sala/ch0/com:command:*:default]", autoupdate="false"}

// Sensore Pir
String Pir "Pir" (Sala) {mqtt="<[localbroker:/Sala/ch1/state:state:default]"} // Uscite GPIO Switch mqttCh3 (Sala) {mqtt=">[localbroker:/Sala/ch3/com:command:ON:ON],>[localbroker:/Sala/ch3/com:command:OFF:OFF],<[localbroker:/Sala/ch3/state:state:default]"} Switch mqttCh4 (Sala) {mqtt=">[localbroker:/Sala/ch4/com:command:ON:ON],>[localbroker:/Sala/ch4/com:command:OFF:OFF],<[localbroker:/Sala/ch4/state:state:default]"} Switch mqttCh5 (Sala) {mqtt=">[localbroker:/Sala/ch5/com:command:ON:ON],>[localbroker:/Sala/ch5/com:command:OFF:OFF],<[localbroker:/Sala/ch5/state:state:default]"} Switch mqttCh6 (Sala) {mqtt=">[localbroker:/Sala/ch6/com:command:ON:ON],>[localbroker:/Sala/ch6/com:command:OFF:OFF],<[localbroker:/Sala/ch6/state:state:default]"} Switch mqttCh8 (Sala) {mqtt=">[localbroker:/Sala/ch8/com:command:ON:ON],>[localbroker:/Sala/ch8/com:command:OFF:OFF],<[localbroker:/Sala/ch8/state:state:default]"}

// Sensore DHT22 (Temperatura e umidità)
Number Sala_Temp  "Temperatura [%.2f] °C"  (Sala) {mqtt="<[localbroker:/Sala/temp7/state:state:default]"}
Number Sala_Humid "Umidita [%.2f] %"          (Sala) {mqtt="<[localbroker:/Sala/humid7/state:state:default]"}

La sitemap:
La sitemap presenta gli elementi in modo grafico sulla app e sul browser
Inseriamo il file default.sitemap (o aggiungiamo questo blocco di codice se il file esiste già) nella cartella dedicata alle rules in OpenHab, nel mio caso: /opt/openhab2/conf/sitemaps/

sitemap demo label="Casa"
{

	Frame label="Sala"{
	Selection item=mqttCh2 label="Led Sala" mappings=["1023"="100%","768"="75%","512"="50%","256"="25%","0"="OFF"]
	Text item=Sala_Temp
	Text item=Sala_Humid
	
	Switch item=mqttCh3  label="Ch3"
	Switch item=mqttCh4  label="Ch4"
	Switch item=mqttCh5  label="Ch5"
	Switch item=mqttCh6  label="Ch6"
	Switch item=mqttCh8  label="Ch8"

	}

	Frame label="Ingresso"{
	Switch item=Rf label="Porta Ingresso" mappings=[2="Apri"]
	}
}

Le rules:
Le rules descrivono le regole che devono intervenire in determinati eventi, come il cambio di stato.
Inseriamo il file LuceNotturna.rules nella cartella dedicata alle rules in OpenHab, nel mio caso: /opt/openhab2/conf/rules/

import org.openhab.core.library.types.*
import org.openhab.core.persistence.*
import org.openhab.model.script.actions.*
import org.openhab.model.script.actions.Timer
import org.openhab.core.types.Command 
import org.openhab.core.items.GenericItem 

var Timer TmrLuceNotturna = null

rule "Accendi Luce Notturna"
 when
   Item Pir changed from OFF to ON
 then
   
   if  Lucenotturna.state == ON {
    logInfo("Luce Notturna","Accende luce notturna")
    if TmrLuceNotturna != null {
      logInfo("Luce Notturna","Nuovo evento, prolungo il timer")
        TmrLuceNotturna.reschedule(now.plusSeconds(20))
    } else {
      var valoreOld = mqttCh2.state
      sendCommand(mqttCh2, 1023)
      TmrLuceNotturna = createTimer(now.plusSeconds(20))[|
        //sendCommand(mqttCh2, valoreOld)
        sendCommand(mqttCh2, 0)
        TmrLuceNotturna = null
      ] 
    }
     
   } else {
     logInfo("Luce Notturna","Non accendo luce notturna")
     TmrLuceNotturna = null
   }
 end 
 
rule "Inizializza LuceNotturna" 
when 
    System started
then
    postUpdate(Lucenotturna, OFF)
end

Caricati i file nelle relative cartelle, OpenHab dovrebbe automanticamente ricaricare le configurazioni.
Accedendo al server OpenHab via Browser vedremo una schermata simile a questa:

Siamo giunti al termine di questo articolo, spero vi sia piaciuto. Vi chiedo la cortesia di condividerlo con amici e conoscenti che condividono questa passione.

 

CiaoBitHome v1.0 di Matteo Dalle Feste è distribuito con Licenza Creative Commons Attribuzione – Non commerciale – Condividi allo stesso modo 4.0 Internazionale.
Based on a work at https://ciaobit.com.
Permessi ulteriori rispetto alle finalità della presente licenza possono essere disponibili presso https://ciaobit.com.