So hier kommt der QA
Einstellungen
--[[
ESP32_Dachboden QA
===================
Mit Dankender Hilfe von @tinman und @SmartHomeEddy aus dem Fibaro Forum
Das QA beruht auf der Vorarbeit von @SmartHomeEddy und dessen Air-Quality Sensor´s
Alles hier zu finden https://forum.fibaro.com/
Der ESP32 liest einen DHT11 aus und gibt die Temperatur und die Luftfeuchtigheit an dieser
QA weiter.
Weiterhin liest der über einen ADS1115 2 Analoge Werte von Lichtsensoren ein.
1 x 0-10.000lx und 1 x 0-100.000lx.
Die Werte werden im ESP32 vorverarbeitet und stehen als direkter Wert zur Verfügung.
Die Datenkommunikation findet über WLAN per Json-Datenpacket statt.
Der ESP meldet sich hierbei beim Router an und holt sich eine IP-Adresse.
Diese Adresse muss bei den Variablen angegeben werden.
Das WLAN-Passwort wie auch der SSID vom Router werden im Code des ESP32 angegeben.
Daraufhin holt sich der QA Zyklisch (Variabel intervall), die Daten vom ESP32 und stellt die Daten über die Childs dem HC3
zur Weiterverarbeitung zur Verfügung.
Diesen Vorgang kann aber auch mit der Taste "Refresh" aktiviert werden.
Die Child´s werden bei der Initialisierung automatisch angelegt.
Eine Erweiterung ist ohne weiteres möglich da der ESP noch einen Haufen von Ein- und Ausgängen hat
ist da noch so vieles möglich.
Die beiden Ausgänge out_1 und out_2 dienen nur zur funktionskontrolle und blinken auf dem ESP32 im wechsel.
Dieser Wechel wird von diesem QA ausgelöst, per Json an den ESP32 gesendet und dort mit der Roten und Grünen LED angezeigt.
Version : ESP32_Dachboden V1.0
Datum : 02.04.2021
Ersteller : Frank Berges
--]]
------------------------- Childs anlegen -------------------------
------------------------------------------------------------------
class 'PolutionSensorTemp'(QuickAppChild)
function PolutionSensorTemp:__init(dev)
QuickAppChild.__init(self,dev)
--self:trace("ESP32_Dachboden initiated, deviceId:",self.id)
end
function PolutionSensorTemp:updateValue(data,userID)
--self:debug("ESP32 Temperature: ",jsonTable.sensordatavalues[1].value))
self:updateProperty("value",tonumber(jsonTable.sensordatavalues[1].value))
end
class 'PolutionSensorHumid'(QuickAppChild)
function PolutionSensorHumid:__init(dev)
QuickAppChild.__init(self,dev)
--self:trace("ESP32 Humidity sensor initiated, deviceId:",self.id)
end
function PolutionSensorHumid:updateValue(data,userID)
self:updateProperty("value",tonumber(jsonTable.sensordatavalues[2].value))
end
class 'PolutionSensorLoLight'(QuickAppChild)
function PolutionSensorLoLight:__init(dev)
QuickAppChild.__init(self,dev)
--self:trace("ESP32 Lo-Aussenlichtsensor initiated, deviceId:",self.id)
end
function PolutionSensorLoLight:updateValue(data,userID)
self:updateProperty("value",tonumber(jsonTable.sensordatavalues[3].value))
self:updateProperty("unit", "lx")
end
class 'PolutionSensorHiLight'(QuickAppChild)
function PolutionSensorHiLight:__init(dev)
QuickAppChild.__init(self,dev)
--self:trace("ESP32 Hi-Aussenlichtsensor initiated, deviceId:",self.id)
end
function PolutionSensorHiLight:updateValue(data,userID)
self:updateProperty("value",tonumber(jsonTable.sensordatavalues[4].value))
self:updateProperty("unit", "lx")
end
------------------------------------------------------------------
-------------------- Childs mit Werten füllen --------------------
------------------------------------------------------------------
local function getChildVariable(child,varName)
for _,v in ipairs(child.properties.quickAppVariables or {}) do
if v.name==varName then return v.value end
end
return ""
end
------------------------------------------------------------------
---------- Childs anlegt ? Wenn nein anlegen vorbereiten ---------
------------------------------------------------------------------
function QuickApp:setupChildDevices()
local cdevs = api.get("/devices?parentId="..self.id) or {} -- Pick up all Child Devices
function self:initChildDevices() end -- Null function, else Fibaro calls it after onInit()...
if #cdevs == 0 then -- If no Child Devices, create them
local initChildData = {
{className="PolutionSensorTemp", name="Temperatur", type="com.fibaro.temperatureSensor", value=0, unit="°C"},
{className="PolutionSensorHumid", name="Luftfeuchte", type="com.fibaro.humiditySensor", value=0, unit="%"},
{className="PolutionSensorLoLight", name="Lo-Aussenlicht", type="com.fibaro.lightSensor", value=0, unit="lx"},
{className="PolutionSensorHiLight", name="Hi-Aussenlicht", type="com.fibaro.lightSensor", value=0, unit="lx"},
}
for _,c in ipairs(initChildData) do
local child = self:createChildDevice(
{name = c.name,
type=c.type,
value=c.value,
unit=c.unit,
initialInterfaces = {},
},
_G[c.className] -- Fetch class constructor from class name
)
child:setVariable("className",c.className) -- Save class name so we know when we load it next time
end
else
for _,child in ipairs(cdevs) do
local className = getChildVariable(child,"className") -- Fetch child class name
local childObject = _G[className](child) -- Create child object from the constructor name
self.childDevices[child.id]=childObject
childObject.parent = self -- Setup parent link to device controller
end
end
end
------------------------------------------------------------------
-------------------- Childs mit Werten füllen --------------------
------------------------------------------------------------------
local function getChildVariable(child,varName)
for _,v in ipairs(child.properties.quickAppVariables or {}) do
if v.name==varName then return v.value end
end
return ""
end
------------------------------------------------------------------
-------------------- Refresch Taste abfragen ---------------------
------------------------------------------------------------------
function QuickApp:button1Event()
self:updateView("button1", "text", "Please wait...")
self:getData()
fibaro.setTimeout(5000, function() -- Pause for [timeout] seconds (default 5 seconds)
self:updateView("button1", "text", "Refresh")
end)
end
------------------------------------------------------------------
---------------------- Labelfeld beschreiben ---------------------
------------------------------------------------------------------
function QuickApp:updateLabels() -- Update labels
self:logging(3,"updateLabels")
labelText = "Measurement: "..os.date("%d-%m-%Y %X", os.time()-jsonTable.age) .."\n" .."\n"
labelText = labelText .."Temperature : " ..jsonTable.sensordatavalues[1].value .." °C" .."\n"
labelText = labelText .."Humidity : " ..jsonTable.sensordatavalues[2].value .." %" .."\n"
labelText = labelText .."Aussenlicht Low : " ..jsonTable.sensordatavalues[3].value .." lx" .."\n"
labelText = labelText .."Aussenlicht Hi : " ..jsonTable.sensordatavalues[4].value .." lx" .."\n" .."\n"
labelText = labelText .."WiFi signal : " ..jsonTable.sensordatavalues[5].value .." dBm" .."\n"
labelText = labelText .."Output 1 : " ..jsonTable.out_1 .."\n"
labelText = labelText .."Output 2 : " ..jsonTable.out_2 .."\n".."\n"
labelText = labelText .."Firmwhareversion : " ..jsonTable.software_version
self:logging(2,"labelText: " ..labelText)
self:updateView("label1", "text", labelText)
end
------------------------------------------------------------------
----------------------- Daten im HC3 Update ----------------------
------------------------------------------------------------------
function QuickApp:updateProperties() -- Update properties
self:logging(3,"updateProperties")
self:updateProperty("log", os.date("%d-%m-%Y %X", os.time()-jsonTable.age) .."\nWiFi " ..jsonTable.sensordatavalues[5].value .."dBm")
end
------------------------------------------------------------------
------------------------ Debuging & Level ------------------------
------------------------------------------------------------------
function QuickApp:logging(level,text) -- Logging function for debug
if tonumber(debugLevel) >= tonumber(level) then
self:debug(text)
end
end
------------------------------------------------------------------
--------------------- Alle Variabel einholen --------------------
------------------------------------------------------------------
function QuickApp:getQuickAppVariables() -- Get all variables
local ipAddress = self:getVariable("ipAddress")
local path = "/data.json" -- Default path is /data.json
interval = tonumber(self:getVariable("interval"))
httpTimeout = 5 -- Default value for http Timeout
userID = tonumber(self:getVariable("userID"))
debugLevel = tonumber(self:getVariable("debugLevel"))
local icon = tonumber(self:getVariable("icon"))
-- Check existence of the mandatory variables, if not, create them with default values
if ipAddress == "" or ipAddress == nil then
ipAddress = "192.168.2.82" -- Default IP address is 192.168.2.82
self:setVariable("ipAddress",ipAddress)
self:trace("Added QuickApp variable ipAddress")
end
if interval == "" or interval == nil then
interval = "146" -- Default interval is 146, normally the sensor renews its readings every 145 seconds
self:setVariable("interval",interval)
self:trace("Added QuickApp variable interval")
interval = tonumber(interval)
end
if userID == "" or userID == nil then
userID = "2" -- Default userID
self:setVariable("userID",userID)
self:trace("Added QuickApp variable iserID")
userID = tonumber(userID)
end
if debugLevel == "" or debugLevel == nil then
debugLevel = "1" -- Default value for debugLevel response in seconds
self:setVariable("debugLevel",debugLevel)
self:trace("Added QuickApp variable debugLevel")
debugLevel = tonumber(debugLevel)
end
if icon == "" or icon == nil then
icon = "0" -- Default icon
self:setVariable("icon",icon)
self:trace("Added QuickApp variable icon")
icon = tonumber(icon)
end
if icon ~= 0 then
self:updateProperty("deviceIcon", icon) -- set user defined icon
end
url = "http://" ..ipAddress ..path
end
------------------------------------------------------------------
----------------- Daten vom ESP32 abholen/senden -----------------
------------------------------------------------------------------
function QuickApp:getData()
self:logging(3,"Start getData")
self:logging(2,"URL: " ..url)
self.httpClient:request(url,
{
options={
headers = {
Accept = "data/json",
data = self:sendeDaten_zusammenstellen() -- Daten zum ESP32 senden
},
method = 'GET'
},
success = function(response) --Daten vom ESP32 holen
self:logging(3,"response status: " ..response.status)
self:logging(3,"headers: " ..response.headers["Content-Type"])
self:logging(2,"Response data: " ..response.data)
if (response.status >= 200 and response.status < 300) then
--self:debug("OK: " .. response.data)
if response.data == nil or response.data == "" or response.data == "[]" then -- Check for empty result
self:warning("Momentan Keine Daten vom ESP32_Dachboden")
else --Gültige Daten erhalten
jsonTable = json.decode(response.data) -- JSON decode from api to lua-table
--jsonTable = json.encode(response.data) -- JSON Kontrolle zeigt was alles im String ist
print("jsonTable =",jsonTable)
self:updateLabels() -- Anzeige der Labels
self:updateProperties()
-- Daten vom ESP32 an die Childs übergeben
for id,child in pairs(self.childDevices) do
child:updateValue(data,userID)
end
end
end
end,
error = function (error)
self:error("error: " ..json.encode(error))
self:updateProperty("log", "error: " ..json.encode(error))
end
})
end --function QuickApp:getData
------------------------------------------------------------------
------------- Daten für ESP32 zum senden vorbereiten -------------
------------------------------------------------------------------
function QuickApp:sendeDaten_zusammenstellen()
--Gewünschte Ausgangszustände des ESP32 einstellen
if out_1 == 0 then
out_1 = 1
out_2 = 0
else
out_1 = 0
out_2 = 1
end
-- json-Datenstring für das Versenden zusammen bauen
print("Time = ",os.date("%H:%M:%S", os.time()))
local daten =
{
time = os.date("%H:%M:%S", os.time()),
out_1 = out_1,
out_2 = out_2
}
self:logging(3,"sende-json : " ..json.encode(daten))
return json.encode(daten)
end
------------------------------------------------------------------
--******************* QuickApp Initialisieren ********************
------------------------------------------------------------------
function QuickApp:onInit()
self:debug("onInit")
-- Setup-Phase
out_1 = 0
out_2 = 0
self:getQuickAppVariables()
self.looptime = interval * 1000
self.httpClient = net.HTTPClient()
self:setupChildDevices()
self:getQuickAppVariables()
-- Dauerlaufschleife
--******************
local function loop()
self:getData() --Vom ESP32 Daten holen und dahin senden
setTimeout(loop, self.looptime)
end
loop()
end
------------------------------------------------------------------
--EOF
ESP32-Dachboden(3).fqa (15,0 KB)
