[LUA] Pilotage VMC (on/off, petite et grande vitesse) avec deux salles de bain

[DavidTrier]

Bonsoir,

Merci beaucoup pour l'info

Pour l'alimentation, c'est clair, j'ai bien saisi. Après réflexion je vais surement le faire en filaire car je projette d'installer mon Raspi dans mon tableau électrique, sur rail DIN. Je vais surement ajouter une carte relais sur le bestiaux.

Par contre, pour le passage PV/GV, je n'ai pas bien saisi : tu en as mis un sur la phase "PV" et un autre sur la phase "GV", c'est bien ça (donc 2 modules)? Faut-il aussi câbler les neutres?

Du coup, si je ne me trompe pas, en faisant ça on perd la possibilité d'utiliser l'interrupteur PV/GV déjà en place?

Un grand merci pour ton aide et un grand bravo pour ce super clair et précis

[vinchz31]

Il faut regarder comment est faite ta VMC.

Moi j'ai regardé "en configuration normale" ce qui partait de l'interrupteur qui permet de gérer la vitesse.
Je me suis rendu compte que cet interrupteur "coupait" un 220v qui venait de la VMC. Quand l'interrupteur est ouvert 'et ne laisse pas passer le 220v envoyé par la VMC, on est en petite vitesse, quand il est fermé, je suis en grande vitesse. Je suppose qu'il y a donc un relais dans la VMC qui en fonction de l'alimentation 220V enclenche ou non la grande vitesse.

J'ai donc mis un relais 433Mhz qui alimente :
- la connexion de l'alimentation principale de la VMC pour le ON/OFF.
- un autre relais 433Mhz connecté sur la connexion de la vitesse.

Ainsi quand on est sur OFF, la VMC est éteinte et le deuxième relais est OFF donc on n'envoie rien sur la connectique de la vitesse.
Quand on est sur ON, le deuxième relais est alimenté et peut gérer la vitesse selon qu'il envoie ou non du 220V.

J'ai en parallèle :
- mis un interrupteur physique qui alimente le relais 433Mhz ON/OFF ce qui me permet d'arrêter physiquement la VMC si je le souhaite (relais ON/OFF et donc relais vitesse plus alimentés).
- laissé l'interrupteur physique de la vitesse (qui arrive donc avec le relais 433Mhz sur la VMC) et qui reste alimenté en 220v (et permet de le couper ou de l'ouvrir) lorsque la VMC est en route. Ceci me permet de déclencher manuellement la grande vitesse si je le souhaite.

Voilà, j'espère que ce sera plus clair.
Très bonne journée !

[DavidTrier]

Super, j'ai tout compris cette fois

Je comprends maintenant pourquoi tu as créé un interrupteur GV. Je vais vérifier mon installation mais je suis quasi sûr que c'est n'est pas pareil sur la mienne. Cela ne m'inquiète pas trop, je trouverai bien la solution adequate (je sais déjà que ça le fait avec un Fibaro 222). Je vais peut-être même tenter de modifier ton script... mais ça, je ne suis pas sûr d'y arriver

Merci beaucoup^pour ton aide

[DavidTrier]

Bonsoir à tous,

Bon, j'ai essayé de bosser un peu et j'ai modifié le script initial pour qu'il prenne en compte une 3ème salle de bain, en fait la cuisine pour ce qui me concerne.

J'ai mis le script en test et il semble bien fonctionner alors je le mets en ligne :

Code : Tout sélectionner

commandArray = {}
 
INTERVAL_MESURE = 2               -- Nombre d'intervals de mesure entre deux cycles d'analyse de l'humidité (en nombre de cycles = nombre de minutes)
SEUIL_DECLENCHEMENT_VMC = 2       -- Augmentation en % au-delà de laquelle on déclenche la GV de la VMC
NbCycles_Max_GV_VMC = 8          -- Nombre de cycles maximum durant lequel la GV de la VMC peut rester ON 
                                  -- à partir du moment où il n'y a plus d'augmentation de l'humidité entre deux mesures                                  
Anticipation_Arret= 1             -- l'arrêt de la grande vitesse se fera à l'humidité avant déclenchement de la GV plus cette valeur
                                  -- ce qui permet d'anticiper l'arrêt de la grande vitesse avant d'atteindre la valeur initiale    
                                    
NOM_INTERRUPTEUR_PILOTAGE_VMC = 'VMC'
NOM_INTERRUPTEUR_OnOff_VMC = 'VMC-OnOff'
NOM_INTERRUPTEUR_GV_VMC = 'VMC-GV'  
NOM_CAPTEUR_HUMIDITE1 = 'Température salle eau'
NOM_CAPTEUR_HUMIDITE2 = 'Température salle bain'
NOM_CAPTEUR_HUMIDITE3 = 'Température cuisine'
NOM_INTERRUPTEUR_DEBUG = 'ModeDebug'   
NOM_INTERRUPTEUR_TEST = 'Test-GV-SDB'   
NOM_CAPTEUR_VIRTUEL_HYGRO_MOYENNE= 'Hygro_Maison_Moyenne'
VALEUR_TEST_HUMIDITE1 = 'VMC_TST_HUM_SDB1'   -- valeur de test pour l'umidité positionné dans les variables domoticz
VALEUR_TEST_HUMIDITE2 = 'VMC_TST_HUM_SDB2'   -- valeur de test pour l'umidité positionné dans les variables domoticz
VALEUR_TEST_HUMIDITE3 = 'VMC_TST_HUM_SDB3'   -- valeur de test pour l'umidité positionné dans les variables domoticz

-- ---------------------------------------------------------------------
-- Récupération de paramètres de Domoticz passés par les interrupteurs					
-- ---------------------------------------------------------------------
  if(otherdevices[NOM_INTERRUPTEUR_DEBUG]=='On') then   -- Si le mode debug est activé dans Domoticz (inter debug sur on)
    MODE_DEBUGG= true
  else
    MODE_DEBUGG= false
  end

  if(otherdevices[NOM_INTERRUPTEUR_TEST]=='On') then   -- Si le mode test est activé dans Domoticz (inter Test sur on)
    MODE_TEST=true
  else
    MODE_TEST=false
  end

 
  if MODE_DEBUGG== true then
    print(' ')
    print(' ')
    print(' ') 
    print(' ')
    print('>>>>>>>>>>>>>>  Script de controle de la VMC v1.0 <<<<<<<<<<<<<<<<<<<<<')
  end
 

-- ----------------------------------------------------------------------------------
-- --Récupération de toutes les variables Domoticz servant au script et remise à 0 --
-- ----------------------------------------------------------------------------------
  VMC_VAR_Compteur_Cycles = tonumber(uservariables['VMC_VAR_Compteur_Cycles'])				-- compteur de cycles
  VMC_VAR_Histo_Hum1_SDB1 = tonumber(uservariables['VMC_VAR_Histo_Hum1_SDB1'])              -- mesure la plus récente SDB1
  VMC_VAR_Histo_Hum1_SDB2 = tonumber(uservariables['VMC_VAR_Histo_Hum1_SDB2'])              -- mesure la plus récente SDB2
  VMC_VAR_Histo_Hum1_SDB3 = tonumber(uservariables['VMC_VAR_Histo_Hum1_SDB3'])              -- mesure la plus récente SDB3
  
  VMC_VAR_Histo_Hum2_SDB1 = tonumber(uservariables['VMC_VAR_Histo_Hum2_SDB1'])              -- mesure la plus ancienne SDB1
  VMC_VAR_Histo_Hum2_SDB2 = tonumber(uservariables['VMC_VAR_Histo_Hum2_SDB2'])              -- mesure la plus ancienne SDB2
  VMC_VAR_Histo_Hum2_SDB3 = tonumber(uservariables['VMC_VAR_Histo_Hum2_SDB3'])              -- mesure la plus ancienne SDB3
  
  VMC_VAR_Cible_Hum_GV_Off_SDB1 = tonumber(uservariables['VMC_VAR_Cible_Hum_GV_Off_SDB1'])   -- Cible à atteindre pour arrêter la deshumidification SDB1 lorsqu'elle est active 
  VMC_VAR_Cible_Hum_GV_Off_SDB2 = tonumber(uservariables['VMC_VAR_Cible_Hum_GV_Off_SDB2'])   -- Cible à atteindre pour arrêter la deshumidification SDB2 lorsqu'elle est active
  VMC_VAR_Cible_Hum_GV_Off_SDB3 = tonumber(uservariables['VMC_VAR_Cible_Hum_GV_Off_SDB3'])   -- Cible à atteindre pour arrêter la deshumidification SDB3 lorsqu'elle est active

  VMC_VAR_TimerSecuriteArret_SDB1 = tonumber(uservariables['VMC_VAR_TimerSecuriteArret_SDB1']) -- Nb de cycles restants avant l'arrête automatique de sécurité de la SDB1
  VMC_VAR_TimerSecuriteArret_SDB2 = tonumber(uservariables['VMC_VAR_TimerSecuriteArret_SDB2']) -- Nb de cycles restants avant l'arrête automatique de sécurité de la SDB2
  VMC_VAR_TimerSecuriteArret_SDB3 = tonumber(uservariables['VMC_VAR_TimerSecuriteArret_SDB3']) -- Nb de cycles restants avant l'arrête automatique de sécurité de la SDB3

  VMC_VAR_Deshumidification_On_SDB1 = tonumber(uservariables['VMC_VAR_Deshumidification_On_SDB1']) -- Vaut 1 si la deshumidification est en cours dans la SDB1, 0 sinon
  VMC_VAR_Deshumidification_On_SDB2 = tonumber(uservariables['VMC_VAR_Deshumidification_On_SDB2']) -- Vaut 1 si la deshumidification est en cours dans la SDB2, 0 sinon 
  VMC_VAR_Deshumidification_On_SDB3 = tonumber(uservariables['VMC_VAR_Deshumidification_On_SDB3']) -- Vaut 1 si la deshumidification est en cours dans la SDB3, 0 sinon

  Cible_Humidite_SDB1 = 0  -- Variable servant à calculer la cible d'humidité lorsque la déshumidification s'active pour la SDB1
  Cible_Humidite_SDB2 = 0  -- Variable servant à calculer la cible d'humidité lorsque la déshumidification s'active pour la SDB2 
  Cible_Humidite_SDB3 = 0  -- Variable servant à calculer la cible d'humidité lorsque la déshumidification s'active pour la SDB3 

  -- ******************************************************************** 
  -- SI L'UTILISATEUR A ACTIVé LA VMC DE MANIERE MANUELLE ON N'EXECUTE --
  --     PAS LE SCRIPT ET ON POSITIONNE LA VMC A LA BONNNE VALEUR
  -- ********************************************************************
  Etat_Pilotage_VMC = tonumber(otherdevices_svalues[NOM_INTERRUPTEUR_PILOTAGE_VMC])  -- récupération de l'état de l'inter 4 positions de pilotage de la VMC
  if Etat_Pilotage_VMC < 30 then   -- Si inter sur mode différent d'automatique (qui vaut 30)
    if Etat_Pilotage_VMC == 0 then -- Si inter sur VMC Off
      print('VMC arretee manuellement via l interrupteur. Sortie du script')
      commandArray[NOM_INTERRUPTEUR_OnOff_VMC] = 'Off'
      commandArray[NOM_INTERRUPTEUR_GV_VMC] = 'Off'
    end
    if Etat_Pilotage_VMC == 10 then -- Si inter sur VMC petite vitesse
      print('VMC positionnee en marche / petite vitesse via l interrupteur. Sortie du script')
      commandArray[NOM_INTERRUPTEUR_OnOff_VMC] = 'On'
      commandArray[NOM_INTERRUPTEUR_GV_VMC] = 'Off'
    end
    if Etat_Pilotage_VMC == 20 then -- si inter sur VMC grande vitesse
      print('VMC positionnee en marche / grande vitesse via l interrupteur. Sortie du script')
      commandArray[NOM_INTERRUPTEUR_OnOff_VMC] = 'On'
      commandArray[NOM_INTERRUPTEUR_GV_VMC] = 'On'
    end
    -- On n'est plus en mode automatique donc on sort du script après l'avoir remis à 0 (réinitialisation de toutes les variables)
    commandArray['Variable:VMC_VAR_Compteur_Cycles'] = '0'
    commandArray['Variable:VMC_VAR_Histo_Hum2_SDB1'] = tostring(otherdevices_humidity[NOM_CAPTEUR_HUMIDITE1])
    commandArray['Variable:VMC_VAR_Histo_Hum1_SDB1'] = tostring(otherdevices_humidity[NOM_CAPTEUR_HUMIDITE1])
    commandArray['Variable:VMC_VAR_Cible_Hum_GV_Off_SDB1'] = '0'
    commandArray['Variable:VMC_VAR_TimerSecuriteArret_SDB1'] = '0'
    commandArray['Variable:VMC_VAR_Deshumidification_On_SDB1'] = '0'
    commandArray['Variable:VMC_VAR_Histo_Hum2_SDB2'] = tostring(otherdevices_humidity[NOM_CAPTEUR_HUMIDITE2])
    commandArray['Variable:VMC_VAR_Histo_Hum1_SDB2'] = tostring(otherdevices_humidity[NOM_CAPTEUR_HUMIDITE2])
    commandArray['Variable:VMC_VAR_Cible_Hum_GV_Off_SDB2'] = '0'
    commandArray['Variable:VMC_VAR_TimerSecuriteArret_SDB2'] = '0'
    commandArray['Variable:VMC_VAR_Deshumidification_On_SDB2'] = '0'
    commandArray['Variable:VMC_VAR_Histo_Hum2_SDB3'] = tostring(otherdevices_humidity[NOM_CAPTEUR_HUMIDITE3])
    commandArray['Variable:VMC_VAR_Histo_Hum1_SDB3'] = tostring(otherdevices_humidity[NOM_CAPTEUR_HUMIDITE3])
    commandArray['Variable:VMC_VAR_Cible_Hum_GV_Off_SDB3'] = '0'
    commandArray['Variable:VMC_VAR_TimerSecuriteArret_SDB3'] = '0'
    commandArray['Variable:VMC_VAR_Deshumidification_On_SDB3'] = '0'
       return commandArray
  end


-- **************************************
-- Recuperation des valeurs d'humidite
-- **************************************
  if (MODE_TEST) then
    -- Si on est en mode test, on prends les valeurs fixées dans les variables DOMOTICZ
    Humidite_Actuelle_SDB1 = tonumber(uservariables['VMC_TST_HUM_SDB1'])
    Humidite_Actuelle_SDB2 = tonumber(uservariables['VMC_TST_HUM_SDB2'])
    Humidite_Actuelle_SDB3 = tonumber(uservariables['VMC_TST_HUM_SDB3'])
    Hygro_Moyenne_Maison= tonumber(uservariables['VMC_TST_HUM_MOYENNE_MAISON'])
  else
    -- Si on est en mode normal, on prends les valeurs remontées par les capteurs
    Humidite_Actuelle_SDB1 = otherdevices_humidity[NOM_CAPTEUR_HUMIDITE1]
    Humidite_Actuelle_SDB2 = otherdevices_humidity[NOM_CAPTEUR_HUMIDITE2]
    Humidite_Actuelle_SDB3 = otherdevices_humidity[NOM_CAPTEUR_HUMIDITE3]
    Hygro_Moyenne_Maison= otherdevices_humidity[NOM_CAPTEUR_VIRTUEL_HYGRO_MOYENNE]
  end
  
-- L'humidité maximum acceptable dans la salle de bain est le maximum de la valeur moyenne humidité en cours dans la maison et de la valeur fixées
-- Cette humidité max permet de maintenir la VMC en petite vitesse même si l'humidité de la salle de bain est redescendue après un pic
  Maximum_Humidite_Acceptable_SDB = math.max(tonumber(uservariables['Hygro_Max_SDB']), Hygro_Moyenne_Maison) 

-- ******************************************************************************
-- Sortie du script si les valeurs d'humidité récupérées ne sont pas exploitables
-- *******************************************************************************
  if (Humidite_Actuelle_SDB1 == 0 or Humidite_Actuelle_SDB1 == nil) then
    print('Pas de signal du capteur ' .. NOM_CAPTEUR_HUMIDITE1 .. '. Sortie du script')
    return commandArray
  end
  if (Humidite_Actuelle_SDB2 == 0 or Humidite_Actuelle_SDB2 == nil) then
    print('Pas de signal du capteur ' .. NOM_CAPTEUR_HUMIDITE2 .. '. Sortie du script')
    return commandArray
  end
  if (Humidite_Actuelle_SDB3 == 0 or Humidite_Actuelle_SDB3 == nil) then
    print('Pas de signal du capteur ' .. NOM_CAPTEUR_HUMIDITE3 .. '. Sortie du script')
    return commandArray
  end
  if (Hygro_Moyenne_Maison== 0 or Hygro_Moyenne_Maison== nil) then
    print('Pas de signal du capteur virtuel d humidite moyenne de la maison, Sortie du script')
    return commandArray
  end



-- ************************************************************************************
-- Le script est executé toutes les minutes, on augmente la valeur du compteur de cycle
-- ************************************************************************************
  VMC_VAR_Compteur_Cycles = VMC_VAR_Compteur_Cycles + 1



-- ***************************************************************************************************
-- On commence par traiter l'humidité globale de la maison pour savoir si la VMC doit être activée ou non
-- ***************************************************************************************************
  if Hygro_Moyenne_Maison > uservariables['Hygro_Max_Maison'] then
    Hygro_Max_Depassee = 1                             -- L'humidité de la maison est trop importante on active la VMC
	commandArray[NOM_INTERRUPTEUR_OnOff_VMC] = 'On'
  else                                                 -- L'humidité de la maison est correcte
    Hygro_Max_Depassee = 0
    if  VMC_VAR_Deshumidification_On_SDB1 == 0 and  VMC_VAR_Deshumidification_On_SDB2 == 0 and  VMC_VAR_Deshumidification_On_SDB3 == 0 then
		if Humidite_Actuelle_SDB1 <= Maximum_Humidite_Acceptable_SDB and Humidite_Actuelle_SDB2 <= Maximum_Humidite_Acceptable_SDB and Humidite_Actuelle_SDB3 <= Maximum_Humidite_Acceptable_SDB then
			commandArray[NOM_INTERRUPTEUR_OnOff_VMC] = 'Off'  -- on arrête la VMC si aucune des salles de bains n'est utilisée et que l'humidité des salles de bain est acceptable
		else
			commandArray[NOM_INTERRUPTEUR_OnOff_VMC] = 'On'  -- on allume la VMC si aucune des salles de bains n'est utilisée mais que l'humidité des salles de bain n'est pas acceptable 
		end
    end
  end


  -- -----------------------------------
  -- Affichage des infos en mode debug
  -- -----------------------------------
  if MODE_DEBUGG== true then
    print('***************')
    print('ETAT ACTUEL : ')
    print('***************')
    if  Hygro_Moyenne_Maison <= uservariables['Hygro_Max_Maison']  and VMC_VAR_Deshumidification_On_SDB1 ==0 and  VMC_VAR_Deshumidification_On_SDB2 == 0  and VMC_VAR_Deshumidification_On_SDB3 ==0 then
		if Humidite_Actuelle_SDB1 <= Maximum_Humidite_Acceptable_SDB and Humidite_Actuelle_SDB2 <= Maximum_Humidite_Acceptable_SDB and Humidite_Actuelle_SDB3 <= Maximum_Humidite_Acceptable_SDB then
			print('[Hygro Maison] - Hygrometrie correcte (' .. Hygro_Moyenne_Maison .. '% vs ' .. uservariables['Hygro_Max_Maison'] ..'% max) et aucune salle de bain en cours d utilisation, desactivation de la vmc')
		else
			print('[Hygro Maison] - Hygrometrie correcte (' .. Hygro_Moyenne_Maison .. '% vs ' .. uservariables['Hygro_Max_Maison'] ..'% max), aucune salle de bain en cours d utilisation mais humidite SDB toujours trop elevee, VMC laissee active en petite vitesse')
	    end
	else
		if VMC_VAR_Deshumidification_On_SDB1 ==0 and  VMC_VAR_Deshumidification_On_SDB2 == 0 and  VMC_VAR_Deshumidification_On_SDB3 == 0 then
		  print('[Hygro Maison] - Hygrometrie incorrect (' .. Hygro_Moyenne_Maison .. '% vs ' .. uservariables['Hygro_Max_Maison'] ..'% max), maintien de la VMC meme si aucune salle de bain en cours d utilisation')
		end
	end
    if VMC_VAR_Deshumidification_On_SDB1 == 0 then
      print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - Deshumidification OFF - actuelle : ' .. Humidite_Actuelle_SDB1 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB1 .. '% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB1 .. '%')
    else
      print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - Deshumidification ON - actuelle : ' .. Humidite_Actuelle_SDB1 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB1 ..'% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB1 .. '% / Cible arret : ' .. VMC_VAR_Cible_Hum_GV_Off_SDB1 .. '% / arret de securite dans ' .. VMC_VAR_TimerSecuriteArret_SDB1 .. ' cycle(s)')
    end 
    if VMC_VAR_Deshumidification_On_SDB2 == 0 then
      print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - Deshumidification OFF - actuelle : ' .. Humidite_Actuelle_SDB2 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB2 .. '% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB2 .. '%')
    else
      print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - Deshumidification ON - actuelle : ' .. Humidite_Actuelle_SDB2 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB2 ..'% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB2 .. '% / Cible arret : ' .. VMC_VAR_Cible_Hum_GV_Off_SDB2 .. '% / arret de securite dans ' .. VMC_VAR_TimerSecuriteArret_SDB2 .. ' cycle(s)')
    end 
    if VMC_VAR_Deshumidification_On_SDB3 == 0 then
      print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - Deshumidification OFF - actuelle : ' .. Humidite_Actuelle_SDB3 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB3 .. '% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB3 .. '%')
    else
      print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - Deshumidification ON - actuelle : ' .. Humidite_Actuelle_SDB3 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB3 ..'% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB3 .. '% / Cible arret : ' .. VMC_VAR_Cible_Hum_GV_Off_SDB3 .. '% / arret de securite dans ' .. VMC_VAR_TimerSecuriteArret_SDB3 .. ' cycle(s)')
    end  
  end
 


if (VMC_VAR_Compteur_Cycles >= INTERVAL_MESURE) then
	-- *************************************************************************************
	-- Si le nombre de cycles a atteint l'interval de mesure fixé on commence l'analyse pour
	-- identifier les besoins d'activation ou désactivation de la grande vitesse de la VMC
	-- *************************************************************************************
	VMC_VAR_Compteur_Cycles = 0   -- remise à 0 du compteur de cycle
	
	
	-- -----------------------------------
	-- Affichage des infos en mode debug
	-- -----------------------------------
	if MODE_DEBUGG== true then
	    	print(' ')
		    print('***************')
		    print('ANALYSE : ')
		    print('***************')
		    print('Nombre de cycles atteint (' .. VMC_VAR_Compteur_Cycles .. '/' .. INTERVAL_MESURE .. '), realisation des tests pour adapter la vitesse VMC')
	end


	-- ***************************************************************************
	-- Initialisation des historiques s'ils ne contiennent aucune information. On 
	-- positionne alors dans les deux historiques les valeurs d'hulidité actuelles
	-- ***************************************************************************
	if (VMC_VAR_Histo_Hum1_SDB1 == 0) then
		-- Initialisation des valeurs historiques
		VMC_VAR_Histo_Hum1_SDB1 = Humidite_Actuelle_SDB1
		VMC_VAR_Histo_Hum2_SDB1 = Humidite_Actuelle_SDB1
	end
	if (VMC_VAR_Histo_Hum1_SDB2 == 0) then
		-- Initialisation des valeurs historiques
		VMC_VAR_Histo_Hum1_SDB2 = Humidite_Actuelle_SDB2
		VMC_VAR_Histo_Hum2_SDB2 = Humidite_Actuelle_SDB2
	end
	if (VMC_VAR_Histo_Hum1_SDB3 == 0) then
		-- Initialisation des valeurs historiques
		VMC_VAR_Histo_Hum1_SDB3 = Humidite_Actuelle_SDB3
		VMC_VAR_Histo_Hum2_SDB3 = Humidite_Actuelle_SDB3
	end

	-- ********************************************************************
	-- Calcul des écarts maximum d'humidité constatés dans chacune des SDB 
	-- ********************************************************************
	Ecart_Max_Humidite_SDB1 = Humidite_Actuelle_SDB1 - math.min(VMC_VAR_Histo_Hum2_SDB1, VMC_VAR_Histo_Hum1_SDB1)
	Ecart_Max_Humidite_SDB2 = Humidite_Actuelle_SDB2 - math.min(VMC_VAR_Histo_Hum2_SDB2, VMC_VAR_Histo_Hum1_SDB2)
  	Ecart_Max_Humidite_SDB3 = Humidite_Actuelle_SDB3 - math.min(VMC_VAR_Histo_Hum2_SDB3, VMC_VAR_Histo_Hum1_SDB3)

	-- -----------------------------------
	-- Affichage des infos en mode debug
	-- -----------------------------------
	if MODE_DEBUGG== true then
		print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - Ecart max d humidite constate sur les dernieres periodes : ' .. Ecart_Max_Humidite_SDB1)
	 	print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - Ecart max d humidite constate sur les dernieres periodes : ' .. Ecart_Max_Humidite_SDB2)
	 	print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - Ecart max d humidite constate sur les dernieres periodes : ' .. Ecart_Max_Humidite_SDB3)
	end
 
 	-- ********************************************************************************************************
	-- Identification de la cible humidité à atteindre si la grande vitesse de la VMC est activée. Il s'agira 
	-- de redescendre à la plus basse des valeurs d'humidité de l'historique + un % défini dans "Anticipation_Arret"   
	-- ********************************************************************************************************
	Cible_Humidite_SDB1 = math.min(VMC_VAR_Histo_Hum2_SDB1, VMC_VAR_Histo_Hum1_SDB1) + Anticipation_Arret
	Cible_Humidite_SDB2 = math.min(VMC_VAR_Histo_Hum2_SDB2, VMC_VAR_Histo_Hum1_SDB2) + Anticipation_Arret
 	Cible_Humidite_SDB3 = math.min(VMC_VAR_Histo_Hum2_SDB3, VMC_VAR_Histo_Hum1_SDB3) + Anticipation_Arret

	-- *****************************************************************************
	-- Sauvegarde dans l'historique des mesures précédentes et de la mesure actuelle
	-- *****************************************************************************
	VMC_VAR_Histo_Hum2_SDB1 = VMC_VAR_Histo_Hum1_SDB1   -- L'historique le plus ancien reçoit l'historique plus récent de l'humidité
	VMC_VAR_Histo_Hum2_SDB2 = VMC_VAR_Histo_Hum1_SDB2 
	VMC_VAR_Histo_Hum2_SDB3 = VMC_VAR_Histo_Hum1_SDB3  
	VMC_VAR_Histo_Hum1_SDB1 = Humidite_Actuelle_SDB1    -- L'historique plus récent reçoit la valeur actuelle d'humidité
	VMC_VAR_Histo_Hum1_SDB2 = Humidite_Actuelle_SDB2
	VMC_VAR_Histo_Hum1_SDB3 = Humidite_Actuelle_SDB3
	

	-- ********************************************************************************************************
	-- Remise à 0 des indicateurs précisant s'il y a eu un déclenchement de la GV pour une des SDB lors
	-- de l'execution du script en cours. Pour l'instant aucune mise en route n'a été décidée/effectuée
 	-- ********************************************************************************************************
	Declenchement_SDB1 = 0
	Declenchement_SDB2 = 0
	Declenchement_SDB3 = 0

	-- *****************************************************************************
	-- Si le ventilateur est off alors qu'un des deux programmes est en route, on 
	-- force l'arrêt des programmes de déshumidification (arrêt manuel extérieur)
	-- *****************************************************************************
	if (otherdevices[NOM_INTERRUPTEUR_GV_VMC]=='Off') and (VMC_VAR_Deshumidification_On_SDB1 == 1 or VMC_VAR_Deshumidification_On_SDB2 ==1 or VMC_VAR_Deshumidification_On_SDB3 ==1)  then
		VMC_VAR_Deshumidification_On_SDB1 = 0
		VMC_VAR_Deshumidification_On_SDB2 = 0
		VMC_VAR_Deshumidification_On_SDB3 = 0
	end


	-- *****************************************************************************************
	-- Si la VMC n'est pas en grande vitesse ou si une des deux SDB n'est pas en grande vitesse
	-- on identifie s'il est nécessaire de mettre en route la marche forcée pour une des SDBs
	-- *****************************************************************************************
  	if otherdevices[NOM_INTERRUPTEUR_GV_VMC]=='Off' or  VMC_VAR_Deshumidification_On_SDB1 == 0 or  VMC_VAR_Deshumidification_On_SDB2 == 0 or  VMC_VAR_Deshumidification_On_SDB3 == 0 then

		-- **************************************************************************
		-- Identification du besoin éventuel de déclenchement de la VMC pour la SDB1
        -- Besoin identifié si humidité > au seuil de déclenchement et que le programme
        -- de déshumidification n'est pas déjà activé pour cette SDB
		-- **************************************************************************
    	if Ecart_Max_Humidite_SDB1 >= SEUIL_DECLENCHEMENT_VMC and VMC_VAR_Deshumidification_On_SDB1 == 0 then
			commandArray[NOM_INTERRUPTEUR_GV_VMC] = 'On'
			commandArray[NOM_INTERRUPTEUR_OnOff_VMC] = 'On'
			VMC_VAR_Deshumidification_On_SDB1 = 1
			VMC_VAR_Cible_Hum_GV_Off_SDB1 = Cible_Humidite_SDB1
			VMC_VAR_TimerSecuriteArret_SDB1 = NbCycles_Max_GV_VMC
			Declenchement_SDB1 = 1

			-- -----------------------------------
			-- Affichage des infos en mode debug
			-- -----------------------------------
		     if MODE_DEBUGG== true then
		       	print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - Augmentation soudaine de l humidite. Activation de la VMC en grande vitesse. Ecart d humidite observe: ' .. Ecart_Max_Humidite_SDB1)
		        print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - Cible a atteindre pour l extinction du ventilateur : ' ..VMC_VAR_Cible_Hum_GV_Off_SDB1)	
			end
    		
		else
      		if MODE_DEBUGG== true and Ecart_Max_Humidite_SDB2 >= SEUIL_DECLENCHEMENT_VMC and VMC_VAR_Deshumidification_On_SDB1 == 0 then
        		print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - Ecart non significatif, pas de mise en route du programme de deshumidification')
      		end
		end 


		-- **************************************************************************
		-- Identification du besoin éventuel de déclenchement de la VMC pour la SDB2
        -- Besoin identifié si humidité > au seuil de déclenchement et que le programme
        -- de déshumidification n'est pas déjà activé pour cette SDB
		-- **************************************************************************
		if Ecart_Max_Humidite_SDB2 >= SEUIL_DECLENCHEMENT_VMC and VMC_VAR_Deshumidification_On_SDB2 == 0 then
			commandArray[NOM_INTERRUPTEUR_GV_VMC] = 'On'
			commandArray[NOM_INTERRUPTEUR_OnOff_VMC] = 'On'
			VMC_VAR_Deshumidification_On_SDB2 = 1
			VMC_VAR_Cible_Hum_GV_Off_SDB2 = Cible_Humidite_SDB2
		        VMC_VAR_TimerSecuriteArret_SDB2 = NbCycles_Max_GV_VMC
			Declenchement_SDB2 = 1

			-- -----------------------------------
			-- Affichage des infos en mode debug
			-- -----------------------------------
			if MODE_DEBUGG== true then
				print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - Augmentation soudaine de l humidite. Activation de la VMC en grande vitesse. Ecart d humidite observe: ' .. Ecart_Max_Humidite_SDB2)
				print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - Cible a atteindre pour l extinction du ventilateur : ' ..VMC_VAR_Cible_Hum_GV_Off_SDB2)
			end
    	else
      		if MODE_DEBUGG== true  and Ecart_Max_Humidite_SDB1 >= SEUIL_DECLENCHEMENT_VMC and VMC_VAR_Deshumidification_On_SDB2 == 0 then
				print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - Ecart non significatif, pas de mise en route du programme de deshumidification')
      		end
    	end 
    	
    	
    	-- **************************************************************************
		-- Identification du besoin éventuel de déclenchement de la VMC pour la SDB3
        -- Besoin identifié si humidité > au seuil de déclenchement et que le programme
        -- de déshumidification n'est pas déjà activé pour cette SDB
		-- **************************************************************************
		if Ecart_Max_Humidite_SDB3 >= SEUIL_DECLENCHEMENT_VMC and VMC_VAR_Deshumidification_On_SDB3 == 0 then
			commandArray[NOM_INTERRUPTEUR_GV_VMC] = 'On'
			commandArray[NOM_INTERRUPTEUR_OnOff_VMC] = 'On'
			VMC_VAR_Deshumidification_On_SDB3 = 1
			VMC_VAR_Cible_Hum_GV_Off_SDB3 = Cible_Humidite_SDB3
		        VMC_VAR_TimerSecuriteArret_SDB3 = NbCycles_Max_GV_VMC
			Declenchement_SDB3 = 1

			-- -----------------------------------
			-- Affichage des infos en mode debug
			-- -----------------------------------
			if MODE_DEBUGG== true then
				print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - Augmentation soudaine de l humidite. Activation de la VMC en grande vitesse. Ecart d humidite observe: ' .. Ecart_Max_Humidite_SDB3)
				print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - Cible a atteindre pour l extinction du ventilateur : ' ..VMC_VAR_Cible_Hum_GV_Off_SDB3)
			end
    	else
      		if MODE_DEBUGG== true  and Ecart_Max_Humidite_SDB1 >= SEUIL_DECLENCHEMENT_VMC and VMC_VAR_Deshumidification_On_SDB2 == 0 then
				print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - Ecart non significatif, pas de mise en route du programme de deshumidification')
      		end
    	end 
	end
	
	
	-- -----------------------------------
	-- Affichage des infos en mode debug
	-- -----------------------------------
	if Ecart_Max_Humidite_SDB1 < SEUIL_DECLENCHEMENT_VMC and Ecart_Max_Humidite_SDB2 < SEUIL_DECLENCHEMENT_VMC and Ecart_Max_Humidite_SDB3 < SEUIL_DECLENCHEMENT_VMC then
      	if MODE_DEBUGG== true then
        	print('Ecarts non significatif sur les deux SDB, pas de mise en route du programme de deshumidification')
      	end
   	end
  
  
	-- *****************************************************************************************
	-- Si la VMC est en grande vitesse après l'analyse du besoin effectuée ci-dessus
	-- *****************************************************************************************
	if (otherdevices[NOM_INTERRUPTEUR_GV_VMC]=='On') or  VMC_VAR_Deshumidification_On_SDB1 == 1 or  VMC_VAR_Deshumidification_On_SDB2 == 1 or  VMC_VAR_Deshumidification_On_SDB3 == 1 then
		if (VMC_VAR_TimerSecuriteArret_SDB1 > 0) then					-- Si le déshumidification est en courspour la SDB1 on diminue
			VMC_VAR_TimerSecuriteArret_SDB1 = VMC_VAR_TimerSecuriteArret_SDB1 - 1	-- la valeur du timer de sécurité pour l'arrêt automatique
		end
		if (VMC_VAR_TimerSecuriteArret_SDB2 > 0) then					-- Si le déshumidification est en courspour la SDB2 on diminue
			VMC_VAR_TimerSecuriteArret_SDB2 = VMC_VAR_TimerSecuriteArret_SDB2 - 1	-- la valeur du timer de sécurité pour l'arrêt automatique
		end
		if (VMC_VAR_TimerSecuriteArret_SDB3 > 0) then					-- Si le déshumidification est en courspour la SDB3 on diminue
			VMC_VAR_TimerSecuriteArret_SDB3 = VMC_VAR_TimerSecuriteArret_SDB3 - 1	-- la valeur du timer de sécurité pour l'arrêt automatique
		end
    end
	
	-- *****************************************************************************************
	-- Si la VMC est en grande vitesse pour la SDB1 et que l'humidité continue d'augmenter
	-- *****************************************************************************************
	if (VMC_VAR_Deshumidification_On_SDB1 == 1) then 
		if (Ecart_Max_Humidite_SDB1 >= SEUIL_DECLENCHEMENT_VMC and Declenchement_SDB1 == 0) then
        	-- S'il y a encore un écart d'humidité constaté sur la dernière période (augmentation humidité toujours en cours) et qu'il n'y a pas 
        	-- eu de déclenchement dans ce cycle, on considère qu'on n'a pas encore atteint l'humidité max et on remet à 0 la VMC_VAR_TimerSecuriteArret_SDB1 
		       VMC_VAR_TimerSecuriteArret_SDB1 = NbCycles_Max_GV_VMC
        		
			if MODE_DEBUGG== true then
          			print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - L humidite est toujours en augmentation, remise a 0 de la Securite Arret. Ecart constate sur la derniere periode : ' .. Ecart_Max_Humidite_SDB1)
        	end

      	end
	end

	-- *****************************************************************************************
	-- Si la VMC est en grande vitesse pour la SDB2 et que l'humidité continue d'augmenter
	-- *****************************************************************************************
	if (VMC_VAR_Deshumidification_On_SDB2 == 1) then 
		if (Ecart_Max_Humidite_SDB2 >= SEUIL_DECLENCHEMENT_VMC  and Declenchement_SDB2 == 0) then
        	-- S'il y a encore un écart d'humidité constaté sur la dernière période (augmentation humidité toujours en cours) et qu'il n'y a pas 
        	-- eu de déclenchement dans ce cycle, on considère qu'on n'a pas encore atteint l'humidité max et on remet à 0 la VMC_VAR_TimerSecuriteArret_SDB2
			VMC_VAR_TimerSecuriteArret_SDB2 = NbCycles_Max_GV_VMC 
			
			if MODE_DEBUGG== true then
				print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - L humidite est toujours en augmentation, remise a 0 de la Securite Arret. Ecart constate sur la derniere periode : ' .. Ecart_Max_Humidite_SDB2)
			end
		end	
	end  

	-- *****************************************************************************************
	-- Si la VMC est en grande vitesse pour la SDB3 et que l'humidité continue d'augmenter
	-- *****************************************************************************************
	if (VMC_VAR_Deshumidification_On_SDB3 == 1) then 
		if (Ecart_Max_Humidite_SDB3 >= SEUIL_DECLENCHEMENT_VMC  and Declenchement_SDB3 == 0) then
        	-- S'il y a encore un écart d'humidité constaté sur la dernière période (augmentation humidité toujours en cours) et qu'il n'y a pas 
        	-- eu de déclenchement dans ce cycle, on considère qu'on n'a pas encore atteint l'humidité max et on remet à 0 la VMC_VAR_TimerSecuriteArret_SDB3
			VMC_VAR_TimerSecuriteArret_SDB3 = NbCycles_Max_GV_VMC 
			
			if MODE_DEBUGG== true then
				print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - L humidite est toujours en augmentation, remise a 0 de la Securite Arret. Ecart constate sur la derniere periode : ' .. Ecart_Max_Humidite_SDB3)
			end
		end	
	end
	
	-- *************************************************************************************************************
	-- Analyse pour identifier si la grande vitesse peut être arrêtée si elle a été activée auparavant. 
	-- Si les Timers de sécurité sont atteints ou que l'humidité est redescendu pour les deux SDB  on 
    -- arrête la grande vitesse et on regarde si on peut arrêter complètement la VMC (si l'humidité globale est Ok)   
	-- *************************************************************************************************************
	if (VMC_VAR_TimerSecuriteArret_SDB1 == 0 or Humidite_Actuelle_SDB1 <= VMC_VAR_Cible_Hum_GV_Off_SDB1) and (VMC_VAR_TimerSecuriteArret_SDB2 == 0 or Humidite_Actuelle_SDB2 <= VMC_VAR_Cible_Hum_GV_Off_SDB2) and (VMC_VAR_TimerSecuriteArret_SDB3 == 0 or Humidite_Actuelle_SDB3 <= VMC_VAR_Cible_Hum_GV_Off_SDB3) then
		commandArray[NOM_INTERRUPTEUR_GV_VMC] = 'Off'
		if Hygro_Max_Depassee == 0 then    																								-- Si l'humidité maximum globale de la maison n'est pas atteinte 
			if Humidite_Actuelle_SDB1<= uservariables['Hygro_Max_SDB'] and Humidite_Actuelle_SDB2<= uservariables['Hygro_Max_SDB'] and Humidite_Actuelle_SDB3<= uservariables['Hygro_Max_SDB'] then -- Si l'humidité des trois SDB est inférieure à l'humidité maximum acceptable dans une SDB
				commandArray[NOM_INTERRUPTEUR_OnOff_VMC] = 'Off'  -- on arrête complètement la VMC
				if MODE_DEBUGG== true then
					print('[Hygro Maison] - Hygrometrie correcte (' .. Hygro_Moyenne_Maison .. '% vs ' .. uservariables['Hygro_Max_Maison'] ..'% max) et aucune salle de bain en cours d utilisation, desactivation de la vmc')
				end
			else
			    -- sinon (hygro maison Ok, mais humidité d'une des deux SDB dépasse la valeur maximum acceptable), on active la VMC en petite vitesse
				commandArray[NOM_INTERRUPTEUR_OnOff_VMC] = 'On'
				if MODE_DEBUGG== true then
					print('[Hygro Maison] - Hygrometrie correcte (' .. Hygro_Moyenne_Maison .. '% vs ' .. uservariables['Hygro_Max_Maison'] ..'% max), aucune salle de bain en cours d utilisation mais humidite SDB toujours trop elevee, VMC laissee active en petite vitesse')
				end
			end 
		end
	end

	
	-- *************************************************************************************************************
	-- Analyse pour identifier s'il faut arrêter  la grande vitesse suite à atteinte du timer de sécurité  sur la SDB1
	-- *************************************************************************************************************
	if (VMC_VAR_TimerSecuriteArret_SDB1 == 0 and Humidite_Actuelle_SDB1 > VMC_VAR_Cible_Hum_GV_Off_SDB1 and VMC_VAR_Deshumidification_On_SDB1 == 1) then
		-- -----------------------------------
		-- Affichage des infos en mode debug
		-- -----------------------------------
		if MODE_DEBUGG== true then
			print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - L humidite n est pas redescendue a sa valeur initiale (avant activation de la grande vitesse) mais le TimeOut de securite pour l arret est atteint. Arret de la grande vitesse de la VMC pour ' .. NOM_CAPTEUR_HUMIDITE1)
		end
		-- Si on a atteint le timer de sécurité on réinitialise l'historique avec la valeur d'hulidité actuelle ainsi que les variables de la SDB1
		VMC_VAR_Histo_Hum2_SDB1 = VMC_VAR_Histo_Hum1_SDB1  
		VMC_VAR_Deshumidification_On_SDB1 = 0
		VMC_VAR_Cible_Hum_GV_Off_SDB1 = 0
		VMC_VAR_TimerSecuriteArret_SDB1 = 0
		VMC_VAR_Deshumidification_On_SDB1 = 0
    end
	
	-- *************************************************************************************************************
	-- Analyse pour identifier s'il faut arrêter  la grande vitesse suite à retour à au taux d'humidité initial sur la SDB1
	-- *************************************************************************************************************
    if (VMC_VAR_TimerSecuriteArret_SDB1 > 0 and Humidite_Actuelle_SDB1 <= VMC_VAR_Cible_Hum_GV_Off_SDB1 and VMC_VAR_Deshumidification_On_SDB1 == 1) then
		-- -----------------------------------
		-- Affichage des infos en mode debug
		-- -----------------------------------
		if MODE_DEBUGG== true then
			print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - L humidite est redescendue a une valeur proche de sa valeur initiale ('.. VMC_VAR_Cible_Hum_GV_Off_SDB1 ..'%). Arret de la grande vitesse de la VMC pour ' .. NOM_CAPTEUR_HUMIDITE1)
		end
		-- On réinitialise l'historique avec la valeur d'hulidité actuelle ainsi que les variables de la SDB1
		VMC_VAR_Histo_Hum2_SDB1 = VMC_VAR_Histo_Hum1_SDB1  
		VMC_VAR_Deshumidification_On_SDB1 = 0
		VMC_VAR_Cible_Hum_GV_Off_SDB1 = 0
		VMC_VAR_TimerSecuriteArret_SDB1 = 0
		VMC_VAR_Deshumidification_On_SDB1 = 0
   	end


	-- *************************************************************************************************************
	-- Analyse pour identifier s'il faut arrêter  la grande vitesse suite à atteinte du timer de sécurité  sur la SDB2
	-- *************************************************************************************************************
	if (VMC_VAR_TimerSecuriteArret_SDB2 == 0 and Humidite_Actuelle_SDB2 > VMC_VAR_Cible_Hum_GV_Off_SDB2 and VMC_VAR_Deshumidification_On_SDB2 == 1) then
		-- -----------------------------------
		-- Affichage des infos en mode debug
		-- -----------------------------------
		if MODE_DEBUGG== true then
			print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - L humidite n est pas redescendue a sa valeur initiale (avant activation de la grande vitesse) mais le TimeOut de securite pour l arret est atteint. Arret de la grande vitesse de la VMC pour ' .. NOM_CAPTEUR_HUMIDITE2)
		end
		-- Si on a atteint le timer de sécurité on réinitialise l'historique avec la valeur d'hulidité actuelle ainsi que les variables de la SDB2
		VMC_VAR_Deshumidification_On_SDB2 = 0
		VMC_VAR_Cible_Hum_GV_Off_SDB2 = 0
		VMC_VAR_TimerSecuriteArret_SDB2 = 0
		VMC_VAR_Deshumidification_On_SDB2 = 0
		VMC_VAR_Histo_Hum2_SDB2 = VMC_VAR_Histo_Hum1_SDB2
	end 


	-- *************************************************************************************************************
	-- Analyse pour identifier s'il faut arrêter  la grande vitesse suite à retour à au taux d'humidité initial sur la SDB2
	-- *************************************************************************************************************
	if (VMC_VAR_TimerSecuriteArret_SDB2 > 0 and Humidite_Actuelle_SDB2 <= VMC_VAR_Cible_Hum_GV_Off_SDB2 and VMC_VAR_Deshumidification_On_SDB2 == 1) then
		-- -----------------------------------
		-- Affichage des infos en mode debug
		-- -----------------------------------		
		if MODE_DEBUGG== true then
			print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - L humidite est redescendue a une valeur proche de sa valeur initiale ('.. VMC_VAR_Cible_Hum_GV_Off_SDB2 ..'%). Arret de la grande vitesse de la VMC pour ' .. NOM_CAPTEUR_HUMIDITE2)
		end
		-- On réinitialise l'historique avec la valeur d'hulidité actuelle ainsi que les variables de la SDB2
		VMC_VAR_Deshumidification_On_SDB2 = 0
		VMC_VAR_Cible_Hum_GV_Off_SDB2 = 0
		VMC_VAR_TimerSecuriteArret_SDB2 = 0
		VMC_VAR_Deshumidification_On_SDB2 = 0
		VMC_VAR_Histo_Hum2_SDB2 = VMC_VAR_Histo_Hum1_SDB2	
	end

	-- *************************************************************************************************************
	-- Analyse pour identifier s'il faut arrêter  la grande vitesse suite à atteinte du timer de sécurité  sur la SDB3
	-- *************************************************************************************************************
	if (VMC_VAR_TimerSecuriteArret_SDB3 == 0 and Humidite_Actuelle_SDB3 > VMC_VAR_Cible_Hum_GV_Off_SDB3 and VMC_VAR_Deshumidification_On_SDB3 == 1) then
		-- -----------------------------------
		-- Affichage des infos en mode debug
		-- -----------------------------------
		if MODE_DEBUGG== true then
			print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - L humidite n est pas redescendue a sa valeur initiale (avant activation de la grande vitesse) mais le TimeOut de securite pour l arret est atteint. Arret de la grande vitesse de la VMC pour ' .. NOM_CAPTEUR_HUMIDITE3)
		end
		-- Si on a atteint le timer de sécurité on réinitialise l'historique avec la valeur d'hulidité actuelle ainsi que les variables de la SDB3
		VMC_VAR_Histo_Hum2_SDB3 = VMC_VAR_Histo_Hum1_SDB3  
		VMC_VAR_Deshumidification_On_SDB3 = 0
		VMC_VAR_Cible_Hum_GV_Off_SDB3 = 0
		VMC_VAR_TimerSecuriteArret_SDB3 = 0
		VMC_VAR_Deshumidification_On_SDB3 = 0
    end
	
	-- *************************************************************************************************************
	-- Analyse pour identifier s'il faut arrêter  la grande vitesse suite à retour à au taux d'humidité initial sur la SDB3
	-- *************************************************************************************************************
    if (VMC_VAR_TimerSecuriteArret_SDB3 > 0 and Humidite_Actuelle_SDB3 <= VMC_VAR_Cible_Hum_GV_Off_SDB3 and VMC_VAR_Deshumidification_On_SDB3 == 1) then
		-- -----------------------------------
		-- Affichage des infos en mode debug
		-- -----------------------------------
		if MODE_DEBUGG== true then
			print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - L humidite est redescendue a une valeur proche de sa valeur initiale ('.. VMC_VAR_Cible_Hum_GV_Off_SDB3 ..'%). Arret de la grande vitesse de la VMC pour ' .. NOM_CAPTEUR_HUMIDITE3)
		end
		-- On réinitialise l'historique avec la valeur d'hulidité actuelle ainsi que les variables de la SDB3
		VMC_VAR_Histo_Hum2_SDB3 = VMC_VAR_Histo_Hum1_SDB3  
		VMC_VAR_Deshumidification_On_SDB3 = 0
		VMC_VAR_Cible_Hum_GV_Off_SDB3 = 0
		VMC_VAR_TimerSecuriteArret_SDB3 = 0
		VMC_VAR_Deshumidification_On_SDB3 = 0
   	end
   	
	-- -----------------------------------
	-- Affichage des infos en mode debug
	-- -----------------------------------	
	if MODE_DEBUGG== true then
		if (Humidite_Actuelle_SDB1 > VMC_VAR_Cible_Hum_GV_Off_SDB1 and VMC_VAR_TimerSecuriteArret_SDB1 > 0 and Declenchement_SDB1 == 0) then
			print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - Deshumidification toujours en cours, humidite actuelle = ' .. Humidite_Actuelle_SDB1.. '% ,cible = ' .. VMC_VAR_Cible_Hum_GV_Off_SDB1 .. '% ,TimerSecurite= ' .. VMC_VAR_TimerSecuriteArret_SDB1)
		end
		if (Humidite_Actuelle_SDB2 > VMC_VAR_Cible_Hum_GV_Off_SDB2 and VMC_VAR_TimerSecuriteArret_SDB2 > 0 and Declenchement_SDB2 == 0) then
			print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - Deshumidification toujours en cours, humidite actuelle = ' .. Humidite_Actuelle_SDB2.. '% ,cible = ' .. VMC_VAR_Cible_Hum_GV_Off_SDB2 .. '% ,TimerSecurite= ' .. VMC_VAR_TimerSecuriteArret_SDB2)
		end
		if (Humidite_Actuelle_SDB3 > VMC_VAR_Cible_Hum_GV_Off_SDB3 and VMC_VAR_TimerSecuriteArret_SDB3 > 0 and Declenchement_SDB3 == 0) then
			print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - Deshumidification toujours en cours, humidite actuelle = ' .. Humidite_Actuelle_SDB3.. '% ,cible = ' .. VMC_VAR_Cible_Hum_GV_Off_SDB3 .. '% ,TimerSecurite= ' .. VMC_VAR_TimerSecuriteArret_SDB3)
		end
	end
else
	-- -----------------------------------
	-- Affichage des infos en mode debug
	-- -----------------------------------	
	if MODE_DEBUGG== true then
		print('Nombre de cycles avant la realisation des tests d adaptation de la vitesse VMC non atteint (' .. VMC_VAR_Compteur_Cycles .. '/' .. INTERVAL_MESURE .. ')')
	end
end




-- *******************************************************
-- Si la VMC est arrêtée on arrête aussi la grande vitesse 
-- *******************************************************
if commandArray[NOM_INTERRUPTEUR_OnOff_VMC] == 'Off' then
        commandArray[NOM_INTERRUPTEUR_GV_VMC] = 'Off'
end



if MODE_DEBUGG== true then
	print(' ')
	print('***************')
	print('ETAT EN SORTIE : ')
	print('***************')


	if VMC_VAR_Deshumidification_On_SDB1 == 0 then
		print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - Deshumidification OFF - actuelle : ' .. Humidite_Actuelle_SDB1 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB1 .. '% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB1 .. '%')
	else
		print('[' .. NOM_CAPTEUR_HUMIDITE1 .. '] - Deshumidification ON - actuelle : ' .. Humidite_Actuelle_SDB1 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB1 ..'% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB1 .. '% / Cible arret : ' .. VMC_VAR_Cible_Hum_GV_Off_SDB1 .. '% / arret de securite dans ' .. VMC_VAR_TimerSecuriteArret_SDB1 .. ' cycle(s)')
	end 

	if VMC_VAR_Deshumidification_On_SDB2 == 0 then
		print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - Deshumidification OFF - actuelle : ' .. Humidite_Actuelle_SDB2 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB2 .. '% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB2 .. '%')
	else
		print('[' .. NOM_CAPTEUR_HUMIDITE2 .. '] - Deshumidification ON - actuelle : ' .. Humidite_Actuelle_SDB2 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB2 ..'% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB2 .. '% / Cible arret : ' .. VMC_VAR_Cible_Hum_GV_Off_SDB2 .. '% / arret de securite dans ' .. VMC_VAR_TimerSecuriteArret_SDB2 .. ' cycle(s)')
	end 
    
    if VMC_VAR_Deshumidification_On_SDB3 == 0 then
		print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - Deshumidification OFF - actuelle : ' .. Humidite_Actuelle_SDB3 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB3 .. '% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB3 .. '%')
	else
		print('[' .. NOM_CAPTEUR_HUMIDITE3 .. '] - Deshumidification ON - actuelle : ' .. Humidite_Actuelle_SDB3 .. '% / Precedente : ' .. VMC_VAR_Histo_Hum1_SDB3 ..'% / Cycle -2 : ' .. VMC_VAR_Histo_Hum2_SDB3 .. '% / Cible arret : ' .. VMC_VAR_Cible_Hum_GV_Off_SDB3 .. '% / arret de securite dans ' .. VMC_VAR_TimerSecuriteArret_SDB3 .. ' cycle(s)')
	end 
    
	if  Hygro_Moyenne_Maison <= uservariables['Hygro_Max_Maison']  and VMC_VAR_Deshumidification_On_SDB1 ==0 and  VMC_VAR_Deshumidification_On_SDB2 == 0 and  VMC_VAR_Deshumidification_On_SDB3 == 0 then
		if Humidite_Actuelle_SDB1 <= Maximum_Humidite_Acceptable_SDB and Humidite_Actuelle_SDB2 <= Maximum_Humidite_Acceptable_SDB and Humidite_Actuelle_SDB3 <= Maximum_Humidite_Acceptable_SDB then
		  print('[Hygro Maison] - Hygrometrie correcte (' .. Hygro_Moyenne_Maison .. '% vs ' .. uservariables['Hygro_Max_Maison'] ..'% max) et aucune salle de bain en cours d utilisation, VMC desactivee')
		else
		  print('[Hygro Maison] - Hygrometrie correcte (' .. Hygro_Moyenne_Maison .. '% vs ' .. uservariables['Hygro_Max_Maison'] ..'% max), aucune salle de bain en cours d utilisation mais humidite SDB toujours trop elevee, VMC laissee active en petite vitesse')
		end  
	else
		if  Hygro_Moyenne_Maison > uservariables['Hygro_Max_Maison'] then
			print('[Hygro Maison] - Hygrometrie incorrecte (' .. Hygro_Moyenne_Maison .. '% vs ' .. uservariables['Hygro_Max_Maison'] ..'% max), VMC activee')
		end
	end
end

-- Sauvegarde des variables
commandArray['Variable:VMC_VAR_Compteur_Cycles'] = tostring(VMC_VAR_Compteur_Cycles)
commandArray['Variable:VMC_VAR_Histo_Hum2_SDB1'] = tostring(VMC_VAR_Histo_Hum2_SDB1)
commandArray['Variable:VMC_VAR_Histo_Hum1_SDB1'] = tostring(VMC_VAR_Histo_Hum1_SDB1)
commandArray['Variable:VMC_VAR_Cible_Hum_GV_Off_SDB1'] = tostring(VMC_VAR_Cible_Hum_GV_Off_SDB1)
commandArray['Variable:VMC_VAR_TimerSecuriteArret_SDB1'] = tostring(VMC_VAR_TimerSecuriteArret_SDB1)
commandArray['Variable:VMC_VAR_Deshumidification_On_SDB1'] = tostring(VMC_VAR_Deshumidification_On_SDB1)


commandArray['Variable:VMC_VAR_Histo_Hum2_SDB2'] = tostring(VMC_VAR_Histo_Hum2_SDB2)
commandArray['Variable:VMC_VAR_Histo_Hum1_SDB2'] = tostring(VMC_VAR_Histo_Hum1_SDB2)
commandArray['Variable:VMC_VAR_Cible_Hum_GV_Off_SDB2'] = tostring(VMC_VAR_Cible_Hum_GV_Off_SDB2)
commandArray['Variable:VMC_VAR_TimerSecuriteArret_SDB2'] = tostring(VMC_VAR_TimerSecuriteArret_SDB2)
commandArray['Variable:VMC_VAR_Deshumidification_On_SDB2'] = tostring(VMC_VAR_Deshumidification_On_SDB2)
 
 
commandArray['Variable:VMC_VAR_Histo_Hum2_SDB3'] = tostring(VMC_VAR_Histo_Hum2_SDB3)
commandArray['Variable:VMC_VAR_Histo_Hum1_SDB3'] = tostring(VMC_VAR_Histo_Hum1_SDB3)
commandArray['Variable:VMC_VAR_Cible_Hum_GV_Off_SDB3'] = tostring(VMC_VAR_Cible_Hum_GV_Off_SDB3)
commandArray['Variable:VMC_VAR_TimerSecuriteArret_SDB3'] = tostring(VMC_VAR_TimerSecuriteArret_SDB3)
commandArray['Variable:VMC_VAR_Deshumidification_On_SDB3'] = tostring(VMC_VAR_Deshumidification_On_SDB3)
 
return commandArray

Il me reste encore un chantier logiciel et je fais appel à vos bonnes idées : j'aimerais allumer la VMC en PV pendant 10 minutes lorsque quelqu'un est aux toilettes, ce qui sera détecté par un détecteur de mouvement et, bien sûr, uniquement si elle est éteinte.

Merci

[DavidTrier]

Ah, j'oubliais : j'aimerais bien aussi pouvoir choisir facilement, via deux potentiomètres virtuels, les valeur de Hygro_Max_SDB et Hygro_Max_Maison alors je vais y travailler!

EDIT : j'ai créé 2 dimmers virtuels qui me permettront de choisir ces 2 niveaux. Il me reste maintenant à comprendre comment les intégrer dans le script, mais on verra ça demain

[vil1driver]

Salut,

Perso je déclenche sur le dépassement de 2 points, de l'humidité absolue (merci papoo) par rapport à la moyenne du jour. L'arrêt est juste temporisé.

[Greg.O]

Perso je déclenche sur le dépassement de 2 points, de l'humidité absolue (merci papoo) par rapport à la moyenne du jour. L'arrêt est juste temporisé.

Tu peux m'en dire plus sur ce qu'est l'humidité absolue ? Je cherche également une formule mathématique qui me permettrait de détecter une élévation anormale de l'humidité (type douche).

[balajol]

Bonsoir Greg.O
Sur le Wiki tu as un script qui détecte l'augmentation Rapide de l'humidité:

https://www.domoticz.com/wiki/Humidity_control


Voici celle que j'utilise avec une traduction des commentaires:

Code : Tout sélectionner

--[[

script_time_humidity.lua        https://www.domoticz.com/wiki/Humidity_control
Créez d'abord les variables utilisateur suivantes dans Domoticz en accédant à <domoticzserver> / # / UserVariables:

humCounter : (type = entier, valeur = 0)
humidityTmin5 : (type = entier, valeur = 0)
humidityTmin10 : (type = entier, valeur = 0)
targetFanOffHumidity : (type = entier, valeur = 0)
fanMaxTimer : (type = entier, valeur = 0)
fanFollowsProgram : (type = entier, valeur = 0)
Note: le script prendra soin des valeurs de ces variables alors ne les éditez pas vous-même! Il est nécessaire de contrôler l'état et les valeurs de report entre chaque exécution de script.

 Ce script contrôle l'humidité dans un réglage de salle de bain typique en détectant
des augmentations relatives de l'humidité sur une courte période.
Bien sûr, il nécessite un capteur d'humidité et un commutateur binaire contrôlant un ventilateur / ventilateur.
(il n'y a pas de disposition pour les ventilateurs à vitesse variable ici!)
 
Comment cela fonctionne (en supposant les constantes par défaut telles que définies ci-dessous):
Toutes les 5 minutes, une lecture est faite. Chaque lecture est stockée ensemble
avec la lecture précédente et est stocké dans deux variables utilisateur (humiditéTmin5 et humiditéTmin10).
Donc, il a deux lectures au cours des 10 dernières minutes.
Il prend ensuite le plus bas des deux et le compare avec la dernière lecture et
calcule un delta.
Si le delta est 3 ou plus (voir les constantes) alors le ventilateur sera démarré
on calcule l'humidité cible et le programme de diminution d'humidité est démarré (fanFollowsProgram = 1).
Dès lors, toutes les 5 minutes, l'humidité actuelle est comparée à
humidité cible stockée. Fondamentalement, si cette cible est atteinte, le ventilateur est éteint
et le 'programme' est terminé.
Bien sûr, il est possible que la cible ne soit jamais atteinte (pourrait commencer à pleuvoir dehors
ou peu importe). Ensuite, il y a un failsafe (FAN_MAX_TIME) après quoi le ventilateur
sera éteint.
 
De plus, il détectera si le ventilateur est éteint manuellement pendant un programme
ou lorsqu'il est allumé avant le démarrage du programme.
 
Le long des lignes, il imprime sur le journal et envoie des notifications
mais bien sûr vous pouvez l'éteindre en supprimant ces lignes.
 

 
--]]
 
print('Controle Ventilation')
 
commandArray = {}
if(otherdevices['VMC_Auto_Val_Cible'] == 'On') then--Ajouté au scipt d'origine pour permettre l'arrêt de ce script
 
-- declare les  constantes
-- A adapter à votre situation
SAMPLE_INTERVAL = 3                 -- temps en minutes quand une logique de script se produira
FAN_DELTA_TRIGGER = 2                -- augmentation de l'humidité qui déclenchera le ventilateur
FAN_MAX_TIME = 12                   --  nombre maximal de cycles d'échantillonnage sur lesquels le ventilateur peut être activé, 
                                    -- au cas où nous n'atteindrions jamais l'humidité cible
TARGET_OFFSET = 1                   -- le ventilateur s'éteint si la cible + le décalage est atteint 
                                    -- (peut-être que cela prend trop de temps pour atteindre la véritable cible due aux serviettes mouillées, etc.)
FAN_NAME = 'VMC'             -- nom exact de l'appareil qui allume / éteint le ventilateur
Memo_On_Vmc= 'Memo_On_VMC_Auto_Val_Cible'--Memorisation Marche VMC par  le Script time (Permet commande Manuelle par "Controle-Humidite-Marche-VMC-6_sansdetecttoil", Blockly device si Memo= Off)
SENSOR_NAME = 'Moyenne_Humidité_Pieces_d_eau'      -- nom exact de l'appareil du capteur d'humidité
 
TEST_MODE = false                   -- lorsque true TEST_MODE_HUMVAR est utilisé à la place du capteur réel
TEST_MODE_HUMVAR = 'testHumidity'   -- valeur d'humidité fausse, donnez-lui une valeur de test dans domoticz / uservars
 
-- obtenir les variables globales:
-- ce script s'exécute toutes les minutes, humCounter est utilisé pour créer des périodes SAMPLE_INTERVAL
humCounter = tonumber(uservariables['humCounter'])
humidityTmin5 = tonumber(uservariables['humidityTmin5'])                -- lecture la plus jeune
humidityTmin10 = tonumber(uservariables['humidityTmin10'])              -- lecture la plus ancienne
targetFanOffHumidity = tonumber(uservariables['targetFanOffHumidity'])  -- Humidité cible
fanMaxTimer = tonumber(uservariables['fanMaxTimer'])
fanFollowsProgram = tonumber(uservariables['fanFollowsProgram'])        -- marqueur indiquant que le 
                                                                        -- programme de diminution est démarré
                                                                        
 
target = 0 -- maintiendra l'humidité cible au démarrage du programme
 
-- obtenir la valeur d'humidité actuelle
if (TEST_MODE) then
    current = tonumber(uservariables[TEST_MODE_HUMVAR])
else
    current = otherdevices_humidity[SENSOR_NAME]
end
 
-- vérifier si le capteur est allumé ou a une lecture bizarre
if (current == 0 or current == nil) then
    print('Valeur Nulle. Ignorer cette donnée')
    return commandArray
end
 
print('Current humidity:' .. current)
print('targetFanOffHumidity:' .. targetFanOffHumidity)
print('humidityTmin5: ' .. humidityTmin5)
print('humidityTmin10: ' .. humidityTmin10)
print('fanMaxTimer: ' .. fanMaxTimer)
print('humCounter:' .. humCounter)
print('fanFollowsProgram:' .. fanFollowsProgram)
 
-- augmenter le compteur de cycles
humCounter = humCounter + 1
 
if (humCounter >= SAMPLE_INTERVAL) then
 
    if (humidityTmin5 == 0) then
        -- initialisation, supposons que c'est la première fois
        humidityTmin5 = current
        humidityTmin10 = current
    end
 
    humCounter = 0 -- reset the cycle counter
 
     -- Choisissez la valeur d'historique la plus basse pour calculer le delta
    -- cela permet également de s'assurer que deux petits deltas relatifs au cours des 2 dernières minutes d'intervalle sont traités comme une plus grande augmentation
    -- et donc va toujours déclencher le ventilateur
    -- Je ne veux pas utiliser un intervalle plus long à la place parce que je veux que le ventilateur commence le plus tôt possible
    -- (donc plutôt après 5 minutes au lieu de 15 minutes car les miroirs de la salle de bain deviennent un peu inutiles ;-)
    delta = current - math.min(humidityTmin10, humidityTmin5)
    print('Delta: ' .. delta)
 
    -- Choisissez la valeur d'historique la plus basse
    target = math.min(humidityTmin10, humidityTmin5) + TARGET_OFFSET
 
    -- décaler les mesures précédentes
    humidityTmin10 = humidityTmin5
    -- et stocker le courant
    humidityTmin5 = current
 
    if (otherdevices[FAN_NAME]=='Off' or (otherdevices[FAN_NAME]=='On' and fanFollowsProgram==0)) then
        -- soit le ventilateur est éteint soit il est allumé mais le programme de diminution n'a pas démarré
        -- dans ce dernier cas, nous commençons le programme de toute façon. Cela pourrait arriver si quelqu'un allume le ventilateur
        -- manuellement parce qu'il / elle est sur le point de prendre une douche et n'aime pas les miroirs humides.
        -- Je ne le fais pas parce que le ventilateur enlève la chaleur de la salle de bains et je veux que cela se produise
        -- aussi tard que possible ;-)
 
        if (fanFollowsProgram == 1 and otherdevices[FAN_NAME]=='Off') then
        -- probablement quelqu'un a éteint la VMC alors que le programme était en cours d'exécution
            fanFollowsProgram = 0
        end
 
        -- voir si nous devons l'activer
        if (delta >= FAN_DELTA_TRIGGER) then
            -- le temps de démarrer le ventilateur
            commandArray[FAN_NAME] = 'On'
            commandArray['OpenURL'] = 'http://192.168.0.13:8091/json.htm?type=setused&idx=47&name=VMC&description=R2%20(Sortie%202)-%20%20FIBARO%20SGS-222%20%20Situe%20pres%20de%20la%20porte%20sectionnelle%2C%20Boitier%20commun%20%C3%A0%20Eclairage%20sous%20sol-Command%C3%A9e%20par%20blocky%20et%20selecteur%20dummy&strparam1=&strparam2=&protected=false&switchtype=0&customimage=165&used=true&addjvalue=0&addjvalue2=0&options='
            commandArray[Memo_On_Vmc] = 'On'
          
            targetFanOffHumidity = target
 
            if (fanFollowsProgram == 1) then
                print('La VMC était déjà en marche mais nous commençons le programme de déshumidification')
            end
 
            fanFollowsProgram = 1
 
            -- régler l'arrêt de sécurité
            fanMaxTimer = FAN_MAX_TIME
 
            print('Augmentation de l humidité, démarrer la VMC , Delta: ' .. delta)
            print('Humidité cible pour démarrer la VMC:' ..targetFanOffHumidity)
            --commandArray['SendNotification'] = 'La VMC est Démarrée # Elle a été activée au niveau d humidité ' .. current .. '#0'
        end
 
    else
        if (fanMaxTimer > 0) then
            -- possible que quelqu'un ait démarré la VMC manuellement
            fanMaxTimer = fanMaxTimer - 1
        end
 
 
        if (fanFollowsProgram == 1) then -- pas démarré manuellement
 
            if (delta >= FAN_DELTA_TRIGGER) then
                -- ok, il y a une autre augmentation de l'humidité FAN_DELTA_TRIGGER
                -- Lorsque cela se produit, nous réinitialisons le fanMaxTimer à un nouveau décompte
                -- parce que nous devons ventiler un peu plus longtemps en raison de l'humidité supplémentaire
                print('Une autre grande augmentation détectée, réinitialisation de la minuterie max. Delta: ' .. delta)
                fanMaxTimer = FAN_MAX_TIME
            end
 
            -- d'abord voir si elle peut être désactivée
            if (current <= targetFanOffHumidity or fanMaxTimer==0) then
                commandArray[FAN_NAME] = 'Off'
                --ci après remplacement icone sur le device "VMC" pour indiquer que la dernière commande a été par ce script
                commandArray['OpenURL'] = 'http://192.168.0.13:8091/json.htm?type=setused&idx=47&name=VMC&description=R2%20(Sortie%202)-%20%20FIBARO%20SGS-222%20%20Situe%20pres%20de%20la%20porte%20sectionnelle%2C%20Boitier%20commun%20%C3%A0%20Eclairage%20sous%20sol-Command%C3%A9e%20par%20blocky%20et%20selecteur%20dummy&strparam1=&strparam2=&protected=false&switchtype=0&customimage=167&used=true&addjvalue=0&addjvalue2=0&options='
                commandArray[Memo_On_Vmc] = 'Off'
                msg = ''
 
                if (fanMaxTimer == 0 and current > targetFanOffHumidity) then
                    msg = 'La cible n est pas atteinte mais le délai de sécurité est déclenché.'
                    print(msg)
                else
                    msg = 'Humidité cible atteinte'
                    print(msg)
                end
 
                print('Eteindre la VMC')
                msg = msg .. 'Désactivation de la VMC'
 
                targetFanOffHumidity = 0
                fanMaxTimer = 0
                fanFollowsProgram = 0
                -- réinitialiser l'historique dans ce cas .. on recommence partout
                -- Tmin10 est toujours dans la zone 'VMC = On'
                humidityTmin10 = humidityTmin5
              -- commandArray['SendNotification'] = 'La VMC est Arrêtée #' .. msg .. '#0'
 
            else
                -- nous n'avons pas encore atteint la cible
                print('Humiditée delta: ' .. delta)
            end
        end
    end
 
    print('Nouvelles valeurs >>>>>>>>>>>')
    print('humidityTmin5: ' .. humidityTmin5)
    print('humidityTmin10: ' .. humidityTmin10)
    print('fanMaxTimer: ' .. fanMaxTimer)
    print('humCounter:' .. humCounter)
    print('fanFollowsProgram:' .. fanFollowsProgram)
    print('------ target: ' .. targetFanOffHumidity)
 
end
 
-- sauvegarder les globales
commandArray['Variable:humCounter'] = tostring(humCounter)
commandArray['Variable:humidityTmin10'] = tostring(humidityTmin10)
commandArray['Variable:humidityTmin5'] = tostring(humidityTmin5)
commandArray['Variable:targetFanOffHumidity'] = tostring(targetFanOffHumidity)
commandArray['Variable:fanMaxTimer'] = tostring(fanMaxTimer)
commandArray['Variable:fanFollowsProgram'] = tostring(fanFollowsProgram)
end 
return commandArray

Je n'ai pas relu les 4 Pages du post, Il a peut être déjà été évoqué
Cdt
Bertrand

[vil1driver]

@Greg.O,

j'utilise 2 scripts, un pour alimenter (par copie de la vraie sonde) une sonde virtuelle de température et humidité (absolue pour le coup)
et un autre qui va lire ce capteur virtuel toutes les 15 minutes et détecter la hausse.

l'avantage est que l'influence du chauffage et des saisons (humidité moyenne variable) n'est plus un problème
garanti satisfait ou remboursé

la formule pour l'obtention de l'humidité absolue nous a été apportée par Papoo (encore merci)
viewtopic.php?f=8&t=6003&p=51064&hilit= ... cle#p51064

1er de type device

Code : Tout sélectionner

-- chargement des modules
dofile('/home/vil1driver/domoticz/scripts/lua/modules.lua')

debug = false  -- true pour voir les logs dans la console log Dz ou false pour ne pas les voir


commandArray = {} 
-- humidité absolue salle de bain
-- mise à jour d'une sonde virtuelle

local sonde = 'salle de bain'

if devicechanged[sonde] then
	local t = getTemp(sonde)
	local hr = getHum(sonde)
	local ha = humAbs(t,hr)
	commandArray[#commandArray+1] = {['UpdateDevice'] = otherdevices_idx[sonde..'_HA']..'|0|'..t..';'..ha..';0'}
end

return commandArray

2nd de type time

Code : Tout sélectionner

-- chargement des modules
dofile('/home/vil1driver/domoticz/scripts/lua/modules.lua')

debug = false  -- true pour voir les logs dans la console log Dz ou false pour ne pas les voir


commandArray = {} 
-- contrôle de la mise en route de la vmc si l'humidité absolue dépasse de +2g d'eau par kg d'air sec / moyenne du jour

local sonde = 'salle de bain_HA'
local vmc = 'vmc'	-- actionneur
local wet = getHum(sonde) > humMoy(sonde) + 2
local timeToCheck = time.min%15 == 0
	
-- mise en route vmc si seuil atteind (check toutes les 15 minutes)

if timeToCheck and wet then
	log('vmc en marche',debug)
	commandArray[#commandArray+1] = {[vmc]='On'}	-- temporisée à 1h00
end

return commandArray

simple et diaboliquement efficace

[Greg.O]

J'ai deux questions :

1. Quelle est ta valeur cible d'humidité absolue : celle d'origine ou bien tu te donnes une marge ?
2. J'imagines que tu arrêtes de mettre à jour ton capteur virtuel tant que la ventilation est en route ?