Extinction lumière en fondu

[jimbo7384]

Bonjour à tous,
j'ai fait ma petite recherche et est ressorti de cette recherche de topic qui traite "partiellement" du sujet mais pas exactement ce que je souhaite faire.

Ma demande est simple.
j'ai un scénario de type bonne nuit qui m'éteint la télévision puis une première lumière (philips leds) puis mon ruban de leds.
Enfin ce scénario allume ma veilleuse à l'étage pour que je puisse tranquillement aller me coucher.

Bon je suis un peu perfectionniste et je trouve bien plus sympa l'extinction avec un fondu linéaire propre et sans interruption.
Ce tuto permet de faire quelque chose mais le rendu n'est pas linéaire et propre :
https://guillaumebraillon.fr/jeedom-sce ... -yeelight/

Donc ma question :
comment faites vous si vous gérer déjà cela chez vous chère jeedomien ou auriez vous une idée de comment faire ?
Merci d'avance pour votre aide !

[jimbo7384]

Personne n'as une idée ? zut je continue à chercher bien sûr de mon côté.

[paulnux]

Bonjour à tous,
j'ai fait ma petite recherche et est ressorti de cette recherche de topic qui traite "partiellement" du sujet mais pas exactement ce que je souhaite faire.

Ma demande est simple.
j'ai un scénario de type bonne nuit qui m'éteint la télévision puis une première lumière (philips leds) puis mon ruban de leds.
Enfin ce scénario allume ma veilleuse à l'étage pour que je puisse tranquillement aller me coucher.

Bon je suis un peu perfectionniste et je trouve bien plus sympa l'extinction avec un fondu linéaire propre et sans interruption.
Ce tuto permet de faire quelque chose mais le rendu n'est pas linéaire et propre :
https://guillaumebraillon.fr/jeedom-sce ... -yeelight/

Donc ma question :
comment faites vous si vous gérer déjà cela chez vous chère jeedomien ou auriez vous une idée de comment faire ?
Merci d'avance pour votre aide !

Bonjour a tu trouvé quelque chose pour faire un rendu linéaire ?

[jimbo7384]

hello,

non j'ai abandonné du coup

[BizZ62]

Bonjour,

As-tu testé avec un enchaînement ? https://lunarok.github.io/jeedom_docs/p ... light.html

[ssc]

Hello,

Pour ma part j'ai copié la démo de leur site et j'ai adapté le script pour piloter l'ampoule à partir de jeedom et des arguments en paramètres.

https://www.yeelight.com/download/devel ... python.zip

Je l'ai mis dans le plugin script (script de type action) et j'ai mis quelques petites fonctions.

Par exemple pour ton besoin il y a la fonction fadein fadeout qui te permettra d'ajuster le temps allumage et d'extinction.

10000 représente la durée en milliseconde.

elif arg1 == "fadeout":
allume("set_power",'"off","smooth",10000')
elif arg1 == "fadein":
allume("set_power",'"on","smooth",10000')


En admettant que ton script s'appelle yeelight.py tu peux ajouter une action avec l'adresse IP de ta yeelight en premier argument et la fonction en deuxième argument.

Pour allumer:
/var/www/html/core/php/../../plugins/script/core/ressources/yeelight.py 192.168.0.50 "on"
ou
/var/www/html/core/php/../../plugins/script/core/ressources/yeelight.py 192.168.0.50 "fadein"

Eteindre
/var/www/html/core/php/../../plugins/script/core/ressources/yeelight.py 192.168.0.50 "off"
ou
/var/www/html/core/php/../../plugins/script/core/ressources/yeelight.py 192.168.0.50 "fadeout"

Les autres fonctions
elif arg1 == "Red":
elif arg1 == "Blue":
elif arg1 == "Green":
elif arg1 == "wakeup_red": (le but était de faire un simulateur d'aube mais ça n'a rien de parfait, para illeurs je ne comptais pas partager le code à l'origine)

Libre à toi d'ajouter ou de modifier les fonctions.
La doc se trouve ici:
https://www.yeelight.com/download/Yeeli ... n_Spec.pdf

Le code que j'ai adapté:

Code : Tout sélectionner

#!/usr/bin/python
import sys
import socket  
import time
import fcntl
import re
import os
import errno
import struct
from threading import Thread
from time import sleep
from collections import OrderedDict

detected_bulbs = {}
bulb_idx2ip = {}
DEBUGGING = False
RUNNING = True
current_command_id = 0
MCAST_GRP = '239.255.255.250'

scan_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 
fcntl.fcntl(scan_socket, fcntl.F_SETFL, os.O_NONBLOCK)
listen_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
listen_socket.bind(("", 1982))
fcntl.fcntl(listen_socket, fcntl.F_SETFL, os.O_NONBLOCK)
mreq = struct.pack("4sl", socket.inet_aton(MCAST_GRP), socket.INADDR_ANY)
listen_socket.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)

def allume(method,param):
  bulb_ip = sys.argv[1]
  port = '55443'
  try:
    tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    print "connect ",bulb_ip, port ,"..."
    tcp_socket.connect((bulb_ip, int(port)))
    msg="{\"id\":" + str(next_cmd_id()) + ",\"method\":\""
    msg += method + "\",\"params\":[" + param + "]}\r\n"
    tcp_socket.send(msg)
    tcp_socket.close()
  except Exception as e:
    print "Unexpected error:", e




def debug(msg):
  if DEBUGGING:
    print msg

def next_cmd_id():
  global current_command_id
  current_command_id += 1
  return current_command_id
    
def send_search_broadcast():
  '''
  multicast search request to all hosts in LAN, do not wait for response
  '''
  multicase_address = (MCAST_GRP, 1982) 
  debug("send search request")
  msg = "M-SEARCH * HTTP/1.1\r\n" 
  msg = msg + "HOST: 239.255.255.250:1982\r\n"
  msg = msg + "MAN: \"ssdp:discover\"\r\n"
  msg = msg + "ST: wifi_bulb"
  scan_socket.sendto(msg, multicase_address)

def bulbs_detection_loop():
  '''
  a standalone thread broadcasting search request and listening on all responses
  '''
  debug("bulbs_detection_loop running")
  search_interval=30000
  read_interval=100
  time_elapsed=0

  while RUNNING:
    if time_elapsed%search_interval == 0:
      send_search_broadcast()

    # scanner
    while True:
      try:
        data = scan_socket.recv(2048)
      except socket.error, e:
        err = e.args[0]
        if err == errno.EAGAIN or err == errno.EWOULDBLOCK:
            break
        else:
            print e
            sys.exit(1)
      handle_search_response(data)

    # passive listener 
    while True:
      try:
        data, addr = listen_socket.recvfrom(2048)
      except socket.error, e:
        err = e.args[0]
        if err == errno.EAGAIN or err == errno.EWOULDBLOCK:
            break
        else:
            print e
            sys.exit(1)
      handle_search_response(data)

    time_elapsed+=read_interval
    sleep(read_interval/1000.0)
  scan_socket.close()
  listen_socket.close()

def get_param_value(data, param):
  '''
  match line of 'param = value'
  '''
  param_re = re.compile(param+":\s*([ -~]*)") #match all printable characters
  match = param_re.search(data)
  value=""
  if match != None:
    value = match.group(1)
    return value
    
def handle_search_response(data):
  '''
  Parse search response and extract all interested data.
  If new bulb is found, insert it into dictionary of managed bulbs. 
  '''
  location_re = re.compile("Location.*yeelight[^0-9]*([0-9]{1,3}(\.[0-9]{1,3}){3}):([0-9]*)")
  match = location_re.search(data)
  if match == None:
    debug( "invalid data received: " + data )
    return 

  host_ip = match.group(1)
  if detected_bulbs.has_key(host_ip):
    bulb_id = detected_bulbs[host_ip][0]
  else:
    bulb_id = len(detected_bulbs)+1
  host_port = match.group(3)
  model = get_param_value(data, "model")
  power = get_param_value(data, "power") 
  bright = get_param_value(data, "bright")
  rgb = get_param_value(data, "rgb")
  # use two dictionaries to store index->ip and ip->bulb map
  detected_bulbs[host_ip] = [bulb_id, model, power, bright, rgb, host_port]
  bulb_idx2ip[bulb_id] = host_ip

def display_bulb(idx):
  if not bulb_idx2ip.has_key(idx):
    print "error: invalid bulb idx"
    return
  bulb_ip = bulb_idx2ip[idx]
  model = detected_bulbs[bulb_ip][1]
  power = detected_bulbs[bulb_ip][2]
  bright = detected_bulbs[bulb_ip][3]
  rgb = detected_bulbs[bulb_ip][4]
  print str(idx) + ": ip=" \
    +bulb_ip + ",model=" + model \
    +",power=" + power + ",bright=" \
    + bright + ",rgb=" + rgb

def display_bulbs():
  print str(len(detected_bulbs)) + " managed bulbs"
  for i in range(1, len(detected_bulbs)+1):
    display_bulb(i)

def operate_on_bulb(idx, method, params):
  '''
  Operate on bulb; no gurantee of success.
  Input data 'params' must be a compiled into one string.
  E.g. params="1"; params="\"smooth\"", params="1,\"smooth\",80"
  '''
  if not bulb_idx2ip.has_key(idx):
    print "error: invalid bulb idx"
    return
  
  bulb_ip=bulb_idx2ip[idx]
  port=detected_bulbs[bulb_ip][5]
  try:
    tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    print "connect ",bulb_ip, port ,"..."
    tcp_socket.connect((bulb_ip, int(port)))
    msg="{\"id\":" + str(next_cmd_id()) + ",\"method\":\""
    msg += method + "\",\"params\":[" + params + "]}\r\n"
    tcp_socket.send(msg)
    tcp_socket.close()
  except Exception as e:
    print "Unexpected error:", e

def toggle_bulb(idx):
  operate_on_bulb(idx, "toggle", "")

def set_bright(idx, bright):
  operate_on_bulb(idx, "set_bright", str(bright))

def print_cli_usage():
  print "Usage:"
  print "  q|quit: quit bulb manager"
  print "  h|help: print this message"
  print "  t|toggle <idx>: toggle bulb indicated by idx"
  print "  b|bright <idx> <bright>: set brightness of bulb with label <idx>"
  print "  r|refresh: refresh bulb list"
  print "  l|list: lsit all managed bulbs"
  
def handle_user_input():
  '''
  User interaction loop. 
  '''
  while True:
    command_line = raw_input("Enter a command: ")
    valid_cli=True
    debug("command_line=" + command_line)
    command_line.lower() # convert all user input to lower case, i.e. cli is caseless
    argv = command_line.split() # i.e. don't allow parameters with space characters
    if len(argv) == 0:
      continue
    if argv[0] == "q" or argv[0] == "quit":
      print "Bye!"
      return
    elif argv[0] == "l" or argv[0] == "list":
      display_bulbs()
    elif argv[0] == "r" or argv[0] == "refresh":
      detected_bulbs.clear()
      bulb_idx2ip.clear()
      send_search_broadcast()
      #sleep(0.5)
      #display_bulbs()
    elif argv[0] == "h" or argv[0] == "help":
      print_cli_usage()
      continue
    elif argv[0] == "t" or argv[0] == "toggle":
      if len(argv) != 2:
        valid_cli=False
      else:
        try:
          i = int(float(argv[1]))
          toggle_bulb(i)
        except:
          valid_cli=False
    elif argv[0] == "b" or argv[0] == "bright":
      if len(argv) != 3:
        print "incorrect argc"
        valid_cli=False
      else:
        try:
          idx = int(float(argv[1]))
          print "idx", idx
          bright = int(float(argv[2]))
          print "bright", bright
          set_bright(idx, bright)
        except:
          valid_cli=False
    else:
      valid_cli=False
          
    if not valid_cli:
      print "error: invalid command line:", command_line
      print_cli_usage()

## main starts here
# print welcome message first
print "Welcome to Yeelight WifiBulb Lan controller"
print_cli_usage
# start the bulb detection thread
detection_thread = Thread(target=bulbs_detection_loop)
detection_thread.start()
# give detection thread some time to collect bulb info
sleep(0.2)
# user interaction loop
#handle_user_input()
arg1 = sys.argv[2]
display_bulb(1)
#arg2 = sys.argv[2]
if arg1 == "on":
	allume("set_power",'"on","smooth",1000')
elif arg1 == "off":
	allume("set_power",'"off","smooth",1000')
elif arg1 == "wakeup":
	allume("set_power",'"on","smooth",300000')
elif arg1 == "sleep":
	allume("set_power",'"off","smooth",300000')
elif arg1 == "fadeout":
	allume("set_power",'"off","smooth",10000')
elif arg1 == "fadein":
	allume("set_power",'"on","smooth",10000')        
elif arg1 == "Red":
	allume("set_hsv","1,50")
elif arg1 == "Blue":
	allume("set_hsv", "240,50")
elif arg1 == "Green":
	allume("set_hsv", "130,50")        
elif arg1 == "wakeup_red":
	allume("set_scene",'"cf",6,2,"180000,2,1000,1, 5000,7,0,0, 1000,1,13458524,1,  5000,7,0,0,  10000,1,13458524,20, 120000,7,0,0"')   
elif arg1 == "no action":
	display_bulb(1)
elif arg1 == "flow":
  	allume("start_cf",  ' 30,2,"300, 1,16711680, 50, 4000,7,0,0, 300, 1,16776960, 50, 7000,7,0,0, 300, 1,16711935, 50, 8000,7,0,0"')
else:
	display_bulbs()
#	allume(str(sys.argv[1]),str(sys.argv[2]))
# user interaction end, tell detection thread to quit and wait
RUNNING = False
detection_thread.join()
# done

[jimbo7384]

Bonjour,

As-tu testé avec un enchaînement ? https://lunarok.github.io/jeedom_docs/p ... light.html

j'ai testé quelque chose y ressemblant j'avais mis le lien en début de topic mais ce n'était pas top.
J'ai totalement abandonné l'idée je ne peux pas passer trop de temps à chaque fois que je met quelque chose en service ce n'est pas du tout WAF lol

[badu69]

salut moi j'ai fais ça (mais je pense qu'on peut faire différemment) Je trouve pas plus simple... si on peut m'aider a rectifier je suis preneur

J'ai l'impression que j'ai fais de la m****

[badu69]

zut! j'ai oublié l'action "Wait"....

[poluket]

Il y a plus simple, avec une boucle et une condition de fin liée a la valeur de la luminosité pour éviter qu'elle tourne a l'infini... Cela te permettrait de de descendre de 5% en 5% sans devoir faire 20 rules

Il te faut 9minutes pour éteindre, c'est voulu? C'est c'est un long fondu

[badu69]

Il y a plus simple, avec une boucle et une condition de fin liée a la valeur de la luminosité pour éviter qu'elle tourne a l'infini... Cela te permettrait de de descendre de 5% en 5% sans devoir faire 20 rules

Il te faut 9minutes pour éteindre, c'est voulu? C'est c'est un long fondu

Merci pour cette info, je vais m'y pencher dessus

Et oui c'est voulu pour les 9 min (si ça baisse trop vite mes enfants n'aiment pas, donc on y va tout en douceur ) qu'est ce qu'on ferait pas pour ses gosses