Bonjour à tous,
Je cherche un moyen -atteignable- pour animer des transitions de couleurs, pouvant être un peu longue, mais toujours douce!
Aujourd’hui, j’ai fait un truc un peu similaire à ce que j’ai dans un scénario, soit avec un sleep sur une boucle d’incrémentation et de mise à jour. Ce sont des transitions de couleur, typiquement chez moi je les lance toutes les 3 à 10 secondes pour un effet « Aube » sans à-coup selon la durée totale.
L’objectif est d’avoir un moteur qui se lance au besoin, dans lequel je référence d’une manière ou d’une autre les équipements/transitions à updater avec leur fréquence d’update, et lancer la mise à jour si nécéssaire - et éviter d’avoir autant de script qui tourne que d’animation à mettre à jour.
J’ai monté en PHP une classe « « moteur » », mais la seule manière que j’ai d’avoir un peu de persistance est de passer par le cache de jeedom… (pour l’exemple ici le moteur tourne « »« »« « à la seconde » »« »" mais j’envisage le paramétrage par la suite)
donc le workflow est :
1.a/ ajout d’une transition au moteur => mise à jour du cache
1.b/ lancement du moteur au besoin
moteur :
2.a / lecture du cache et désérialisation
2.b/ boucle sur les transitions référencées
2.b.i / calcul si la mise à jour est requise
2.b.ii/ récup de l’éqlogic au besoin
2.b.iii/mise à jour de l’équipement
2.c.i/vérif si la transistion est finie
2.c.ii/ suppression de la liste de la transistion au besoin
3/ si toujours des transition en cours : Mise à jour du cache
4/ sleep 1 seconde
5/ relance du cycle moteur
Ce qui est vachement lourd je trouve, surtout vu les écritures de cache incessante, ça sent le sd killer,
et je trouve ça pas vraiment propre…
J’ai tenté de travaillé en static, d’implémenter un singleton, mais je perd toujours la persistance des infos à un moment ou un autre.
Au final le sleep m’ennuie moins que les écriture/lecture du cache, je fais à mon niveau.
J’aurai imaginer pouvoir atteindre les objets en mémoire, tout du moins les faire persister dans le scope !?
J’ai tenter de croiser les référence aux objets dans les classe, mais perte de la persistance également.
Du coup je suis à la recherche de tout autre piste! là c’est fonctionnel mais pas performant.
Pouvez vous m’aiguiller?
la classe du moteur en l'état
<?php
/* * ***************************Includes********************************* */
require_once __DIR__ . '/../../../../core/php/core.inc.php';
class CT_motor {
private const CT_CACHE_NAME="COLOR_TRANSITION::";
private const CT_CACHE_ARRAY="serial_array";
public static $countLoop=0;
private function __construct() {
}
//remove d'un élément par id
public static function removeCTA($id){
log::add('ColorTransition_actuator', 'debug', '║ ║ ╟─── MOTOR REMOVE '.$id);
$jcacheExist=cache::exist(self::CT_CACHE_NAME.self::CT_CACHE_ARRAY);
if(!$jcacheExist)return false;
$cacheJson=cache::byKey(self::CT_CACHE_NAME.self::CT_CACHE_ARRAY)->getValue();
$cacheArr=json_decode($cacheJson,true);
if(!is_null($cacheArr[$id])){
unset($cacheArr[$id]);
log::add('ColorTransition_actuator', 'debug', '║ ║ ╟─── new cache '.json_encode($cacheArr));
cache::set(self::CT_CACHE_NAME.self::CT_CACHE_ARRAY, json_encode($cacheArr));
return true;
}else{
return false;
}
}
// ajout d'un élément dans le cache
public static function addCTA($cta_tr){
// $cta_tr est un objet qui référence l'équipement, et les données de la transition en durée, steps, ....
log::add('ColorTransition_actuator', 'debug', '║ ║ ╟─── MOTOR ADD '.self::CT_CACHE_NAME.self::CT_CACHE_ARRAY);
$jcacheExist=cache::exist(self::CT_CACHE_NAME.self::CT_CACHE_ARRAY);
if($jcacheExist){
$cacheJson=cache::byKey(self::CT_CACHE_NAME.self::CT_CACHE_ARRAY)->getValue();
$cacheArr=json_decode($cacheJson,true);
}else{
$cacheArr=Array();
}
$arrAdd=$cta_tr->getArray();
$keyName=strval($arrAdd['id']);
$cacheArr[$keyName]=$arrAdd;
cache::set(self::CT_CACHE_NAME.self::CT_CACHE_ARRAY, json_encode($cacheArr));
// mise à l'index initial de l'équipement cible
$eq= eqLogic::byId($arrAdd['id']);
if(!is_object($eq)){
log::add('ColorTransition_actuator_mouv', 'error', '║ ║ ╟─── #############" MOTOR Error id :'.$cta_tr['id']);
}
$eq->refreshEquipementColor($arrAdd['move_index']);
if(!$jcacheExist || count($cacheArr)==1)self::startTime();
}
/// le coeur du moteur
private static function startTime(){
self::$countLoop+=1;
log::add('ColorTransition_actuator_mouv', 'info', '║ ║ ╟─── MOTOR TICK '.self::$countLoop);
$jcacheExist=cache::exist(self::CT_CACHE_NAME.self::CT_CACHE_ARRAY);
if(!$jcacheExist)return;
$cacheArr=json_decode(cache::byKey(self::CT_CACHE_NAME.self::CT_CACHE_ARRAY)->getValue(),true);
$finalArray=array();
foreach($cacheArr as $id=>$cta_tr){
log::add('ColorTransition_actuator_mouv', 'info', '║ ║ ╟─── MOTOR CTA : '.$id);
$cta_tr['curStep']+=1;
if ($cta_tr['curStep'] >= $cta_tr['dur_interval']){ // si on doit mettre à jour
$eq= eqLogic::byId($cta_tr['id']);
if(!is_object($eq)){
log::add('ColorTransition_actuator_mouv', 'error', '║ ║ ╟─── #############" MOTOR Error id :'.$cta_tr['id']);
}
$cta_tr['curStep']=0;
$cta_tr['move_index']+=$cta_tr['index_step'];
$eq->refreshEquipementColor($cta_tr['move_index']);
}
//log::add('ColorTransition_actuator_mouv', 'info', '║ ║ ╟─ dur : '.$cta_tr['dur']);
$cta_tr['dur']-=1;
if($cta_tr['dur']>0){
$finalArray[$id]=$cta_tr;
}
}
log::add('ColorTransition_actuator_mouv', 'info', '║ ║ ╟─ cache array : '.json_encode($finalArray));
if(count($finalArray)>0 && self::$countLoop<100){
cache::set(self::CT_CACHE_NAME.self::CT_CACHE_ARRAY, json_encode($finalArray));
sleep(1);
self::startTime();
}else{
cache::delete(self::CT_CACHE_NAME.self::CT_CACHE_ARRAY);
log::add('ColorTransition_actuator_mouv', 'info', '║ ║ ╟─--------------------------- MOTOR END : ');
self::$countLoop=0;
}
}
}
!!
mais j’imagine qu’on peut aussi faire un « vrai » démon en php même si ce n’est peut être pas nécessaire ici… Je suppose que la méthode static dont tu parle c’est demon_start / demon_stop et demon_info ?