def get_sunrise_sunset(self, date=None):
if self.data['sunrise_time'] is not None and self.data[
'sunset_time'] is not None:
if date is None:
date = dt_now(self.data['timezone'])
sunrise = date.replace(
hour=int(self.data['sunrise_time'].strftime("%H")),
minute=int(self.data['sunrise_time'].strftime("%M")),
second=int(self.data['sunrise_time'].strftime("%S")),
microsecond=int(self.data['sunrise_time'].strftime("%f")))
sunset = date.replace(
hour=int(self.data['sunset_time'].strftime("%H")),
minute=int(self.data['sunset_time'].strftime("%M")),
second=int(self.data['sunset_time'].strftime("%S")),
microsecond=int(self.data['sunset_time'].strftime("%f")))
solar_noon = sunrise + (sunset - sunrise) / 2
solar_midnight = sunset + (
(sunrise + timedelta(days=1)) - sunset) / 2
else:
import astral
location = astral.Location()
location.name = 'name'
location.region = 'region'
location.latitude = self.data['latitude']
location.longitude = self.data['longitude']
location.elevation = self.data['elevation']
_LOGGER.debug("Astral location: " + str(location))
if self.data['sunrise_time'] is not None:
if date is None:
date = dt_now(self.data['timezone'])
sunrise = date.replace(
hour=int(self.data['sunrise_time'].strftime("%H")),
minute=int(self.data['sunrise_time'].strftime("%M")),
second=int(self.data['sunrise_time'].strftime("%S")),
microsecond=int(self.data['sunrise_time'].strftime("%f")))
else:
sunrise = location.sunrise(date)
if self.data['sunset_time'] is not None:
if date is None:
date = dt_now(self.data['timezone'])
sunset = date.replace(
hour=int(self.data['sunset_time'].strftime("%H")),
minute=int(self.data['sunset_time'].strftime("%M")),
second=int(self.data['sunset_time'].strftime("%S")),
microsecond=int(self.data['sunset_time'].strftime("%f")))
else:
sunset = location.sunset(date)
solar_noon = location.solar_noon(date)
solar_midnight = location.solar_midnight(date)
if self.data['sunrise_offset'] is not None:
sunrise = sunrise + self.data['sunrise_offset']
if self.data['sunset_offset'] is not None:
sunset = sunset + self.data['sunset_offset']
return {
SUN_EVENT_SUNRISE: sunrise.astimezone(self.data['timezone']),
SUN_EVENT_SUNSET: sunset.astimezone(self.data['timezone']),
'solar_noon': solar_noon.astimezone(self.data['timezone']),
'solar_midnight': solar_midnight.astimezone(self.data['timezone'])
}
def get_sunrise_sunset(self, date=None):
if self.data['sunrise_time'] is not None and self.data[
'sunset_time'] is not None:
if date is None:
date = dt_now()
sunrise = date.replace(
hour=int(self.data['sunrise_time'].strftime("%H")),
minute=int(self.data['sunrise_time'].strftime("%M")),
second=int(self.data['sunrise_time'].strftime("%S")),
microsecond=int(self.data['sunrise_time'].strftime("%f")))
sunset = date.replace(
hour=int(self.data['sunset_time'].strftime("%H")),
minute=int(self.data['sunset_time'].strftime("%M")),
second=int(self.data['sunset_time'].strftime("%S")),
microsecond=int(self.data['sunset_time'].strftime("%f")))
solar_noon = sunrise + (sunset - sunrise) / 2
solar_midnight = sunset + (
(sunrise + timedelta(days=1)) - sunset) / 2
else:
location = astral.Location()
location.latitude = self.data['latitude']
location.longitude = self.data['longitude']
if self.data['sunrise_time'] is not None:
if date is None:
date = dt_now()
sunrise = date.replace(
hour=int(self.data['sunrise_time'].strftime("%H")),
minute=int(self.data['sunrise_time'].strftime("%M")),
second=int(self.data['sunrise_time'].strftime("%S")),
microsecond=int(self.data['sunrise_time'].strftime("%f")))
else:
sunrise = location.sunrise(date)
if self.data['sunset_time'] is not None:
if date is None:
date = dt_now()
sunset = date.replace(
hour=int(self.data['sunset_time'].strftime("%H")),
minute=int(self.data['sunset_time'].strftime("%M")),
second=int(self.data['sunset_time'].strftime("%S")),
microsecond=int(self.data['sunset_time'].strftime("%f")))
else:
sunset = location.sunset(date)
solar_noon = location.solar_noon(date)
solar_midnight = location.solar_midnight(date)
if self.data['sunrise_offset'] is not None:
sunrise = sunrise + self.data['sunrise_offset']
if self.data['sunset_offset'] is not None:
sunset = sunset + self.data['sunset_offset']
return {
'sunrise': sunrise,
'sunset': sunset,
'solar_noon': solar_noon,
'solar_midnight': solar_midnight
}
def flux_update(self, now=None):
"""Update all the lights using flux."""
if now is None:
now = dt_now()
sunset = next_setting(self.hass, SUN).replace(day=now.day,
month=now.month,
year=now.year)
start_time = self.find_start_time(now)
stop_time = now.replace(hour=self._stop_time.hour,
minute=self._stop_time.minute,
second=0)
if start_time < now < sunset:
# Daytime
time_state = 'day'
temp_range = abs(self._start_colortemp - self._sunset_colortemp)
day_length = int(sunset.timestamp() - start_time.timestamp())
seconds_from_start = int(now.timestamp() - start_time.timestamp())
percentage_complete = seconds_from_start / day_length
temp_offset = temp_range * percentage_complete
if self._start_colortemp > self._sunset_colortemp:
temp = self._start_colortemp - temp_offset
else:
temp = self._start_colortemp + temp_offset
else:
# Nightime
time_state = 'night'
if now < stop_time and now > start_time:
now_time = now
else:
now_time = stop_time
temp_range = abs(self._sunset_colortemp - self._stop_colortemp)
night_length = int(stop_time.timestamp() - sunset.timestamp())
seconds_from_sunset = int(now_time.timestamp() -
sunset.timestamp())
percentage_complete = seconds_from_sunset / night_length
temp_offset = temp_range * percentage_complete
if self._sunset_colortemp > self._stop_colortemp:
temp = self._sunset_colortemp - temp_offset
else:
temp = self._sunset_colortemp + temp_offset
x_val, y_val, b_val = color_RGB_to_xy(*color_temperature_to_rgb(temp))
brightness = self._brightness if self._brightness else b_val
if self._mode == MODE_XY:
set_lights_xy(self.hass, self._lights, x_val,
y_val, brightness)
_LOGGER.info("Lights updated to x:%s y:%s brightness:%s, %s%%"
" of %s cycle complete at %s", x_val, y_val,
brightness, round(
percentage_complete * 100), time_state,
as_local(now))
else:
# Convert to mired and clamp to allowed values
mired = color_temperature_kelvin_to_mired(temp)
mired = max(HASS_COLOR_MIN, min(mired, HASS_COLOR_MAX))
set_lights_temp(self.hass, self._lights, mired, brightness)
_LOGGER.info("Lights updated to mired:%s brightness:%s, %s%%"
" of %s cycle complete at %s", mired, brightness,
round(percentage_complete * 100),
time_state, as_local(now))
def flux_update(self, now=None):
"""Update all the lights using flux."""
if now is None:
now = dt_now()
sunset = next_setting(self.hass, SUN).replace(day=now.day,
month=now.month,
year=now.year)
start_time = self.find_start_time(now)
stop_time = now.replace(hour=self._stop_time.hour,
minute=self._stop_time.minute,
second=0)
if start_time < now < sunset:
# Daytime
time_state = 'day'
temp_range = abs(self._start_colortemp - self._sunset_colortemp)
day_length = int(sunset.timestamp() - start_time.timestamp())
seconds_from_start = int(now.timestamp() - start_time.timestamp())
percentage_complete = seconds_from_start / day_length
temp_offset = temp_range * percentage_complete
if self._start_colortemp > self._sunset_colortemp:
temp = self._start_colortemp - temp_offset
else:
temp = self._start_colortemp + temp_offset
else:
# Nightime
time_state = 'night'
if now < stop_time and now > start_time:
now_time = now
else:
now_time = stop_time
temp_range = abs(self._sunset_colortemp - self._stop_colortemp)
night_length = int(stop_time.timestamp() - sunset.timestamp())
seconds_from_sunset = int(now_time.timestamp() -
sunset.timestamp())
percentage_complete = seconds_from_sunset / night_length
temp_offset = temp_range * percentage_complete
if self._sunset_colortemp > self._stop_colortemp:
temp = self._sunset_colortemp - temp_offset
else:
temp = self._sunset_colortemp + temp_offset
x_val, y_val, b_val = color_RGB_to_xy(*color_temperature_to_rgb(temp))
brightness = self._brightness if self._brightness else b_val
if self._disable_brightness_adjust:
brightness = None
if self._mode == MODE_XY:
set_lights_xy(self.hass, self._lights, x_val,
y_val, brightness)
_LOGGER.info("Lights updated to x:%s y:%s brightness:%s, %s%%"
" of %s cycle complete at %s", x_val, y_val,
brightness, round(
percentage_complete * 100), time_state, now)
else:
# Convert to mired and clamp to allowed values
mired = color_temperature_kelvin_to_mired(temp)
mired = max(HASS_COLOR_MIN, min(mired, HASS_COLOR_MAX))
set_lights_temp(self.hass, self._lights, mired, brightness)
_LOGGER.info("Lights updated to mired:%s brightness:%s, %s%%"
" of %s cycle complete at %s", mired, brightness,
round(percentage_complete * 100), time_state, now)
def flux_update(self, now=None):
"""Update all the lights using flux."""
if now is None:
now = dt_now()
sunset = next_setting(self.hass, SUN).replace(day=now.day,
month=now.month,
year=now.year)
start_time = self.find_start_time(now)
stop_time = now.replace(hour=self._stop_time.hour,
minute=self._stop_time.minute,
second=0)
if start_time < now < sunset:
# Daytime
time_state = 'day'
temp_range = abs(self._start_colortemp - self._sunset_colortemp)
day_length = int(sunset.timestamp() - start_time.timestamp())
seconds_from_start = int(now.timestamp() - start_time.timestamp())
percentage_complete = seconds_from_start / day_length
temp_offset = temp_range * percentage_complete
if self._start_colortemp > self._sunset_colortemp:
temp = self._start_colortemp - temp_offset
else:
temp = self._start_colortemp + temp_offset
else:
# Nightime
time_state = 'night'
if now < stop_time and now > start_time:
now_time = now
else:
now_time = stop_time
temp_range = abs(self._sunset_colortemp - self._stop_colortemp)
night_length = int(stop_time.timestamp() - sunset.timestamp())
seconds_from_sunset = int(now_time.timestamp() -
sunset.timestamp())
percentage_complete = seconds_from_sunset / night_length
temp_offset = temp_range * percentage_complete
if self._sunset_colortemp > self._stop_colortemp:
temp = self._sunset_colortemp - temp_offset
else:
temp = self._sunset_colortemp + temp_offset
if self._mode == MODE_XY:
x_val, y_val, b_val = color_RGB_to_xy(*temp_to_rgb(temp))
brightness = self._brightness if self._brightness else b_val
set_lights_xy(self.hass, self._lights, x_val,
y_val, brightness)
_LOGGER.info("Lights updated to x:%s y:%s brightness:%s, %s%%"
" of %s cycle complete at %s", x_val, y_val,
brightness, round(
percentage_complete * 100), time_state,
as_local(now))
else:
set_lights_temp(self.hass, self._lights, temp, self._mode)
_LOGGER.info("Lights updated to temp:%s, %s%%"
" of %s cycle complete at %s", temp,
round(percentage_complete * 100),
time_state, as_local(now))
def get_sunrise_sunset(self, date=None):
if (self.data["sunrise_time"] is not None
and self.data["sunset_time"] is not None):
if date is None:
date = dt_now(self.data["timezone"])
sunrise = date.replace(**self._time_dict("sunrise_time"))
sunset = date.replace(**self._time_dict("sunset_time"))
solar_noon = sunrise + (sunset - sunrise) / 2
solar_midnight = sunset + (
(sunrise + timedelta(days=1)) - sunset) / 2
else:
import astral
location = astral.Location()
location.name = "name"
location.region = "region"
location.latitude = self.data["latitude"]
location.longitude = self.data["longitude"]
location.elevation = self.data["elevation"]
_LOGGER.debug("Astral location: " + str(location))
if self.data["sunrise_time"] is not None:
if date is None:
date = dt_now(self.data["timezone"])
sunrise = date.replace(**self._time_dict("sunrise_time"))
else:
sunrise = location.sunrise(date)
if self.data["sunset_time"] is not None:
if date is None:
date = dt_now(self.data["timezone"])
sunset = date.replace(**self._time_dict("sunset_time"))
else:
sunset = location.sunset(date)
solar_noon = location.solar_noon(date)
solar_midnight = location.solar_midnight(date)
if self.data["sunrise_offset"] is not None:
sunrise = sunrise + self.data["sunrise_offset"]
if self.data["sunset_offset"] is not None:
sunset = sunset + self.data["sunset_offset"]
return {
SUN_EVENT_SUNRISE: sunrise.astimezone(self.data["timezone"]),
SUN_EVENT_SUNSET: sunset.astimezone(self.data["timezone"]),
"solar_noon": solar_noon.astimezone(self.data["timezone"]),
"solar_midnight": solar_midnight.astimezone(self.data["timezone"]),
}
def flux_update(self, now=dt_now()):
"""Update all the lights using flux."""
sunset = next_setting(self.hass, SUN).replace(day=now.day,
month=now.month,
year=now.year)
start_time = self.find_start_time(now)
stop_time = now.replace(hour=self._stop_time.hour,
minute=self._stop_time.minute,
second=0)
if start_time < now < sunset:
# Daytime
time_state = 'day'
temp_range = abs(self._start_colortemp - self._sunset_colortemp)
day_length = int(sunset.timestamp() - start_time.timestamp())
seconds_from_start = int(now.timestamp() - start_time.timestamp())
percentage_complete = seconds_from_start / day_length
temp_offset = temp_range * percentage_complete
if self._start_colortemp > self._sunset_colortemp:
temp = self._start_colortemp - temp_offset
else:
temp = self._start_colortemp + temp_offset
else:
# Nightime
time_state = 'night'
if now < stop_time and now > start_time:
now_time = now
else:
now_time = stop_time
temp_range = abs(self._sunset_colortemp - self._stop_colortemp)
night_length = int(stop_time.timestamp() - sunset.timestamp())
seconds_from_sunset = int(now_time.timestamp() -
sunset.timestamp())
percentage_complete = seconds_from_sunset / night_length
temp_offset = temp_range * percentage_complete
if self._sunset_colortemp > self._stop_colortemp:
temp = self._sunset_colortemp - temp_offset
else:
temp = self._sunset_colortemp + temp_offset
if self._mode == MODE_XY:
x_val, y_val, b_val = color_RGB_to_xy(*temp_to_rgb(temp))
brightness = self._brightness if self._brightness else b_val
set_lights_xy(self.hass, self._lights, x_val,
y_val, brightness)
_LOGGER.info("Lights updated to x:%s y:%s brightness:%s, %s%%"
" of %s cycle complete at %s", x_val, y_val,
brightness, round(
percentage_complete * 100), time_state,
as_local(now))
else:
set_lights_temp(self.hass, self._lights, temp, self._mode)
_LOGGER.info("Lights updated to temp:%s, %s%%"
" of %s cycle complete at %s", temp,
round(percentage_complete * 100),
time_state, as_local(now))
def sign_for_device(device):
"""Generate signature for divice"""
if not device:
return ['', '']
now = dt_now()
timestamp = int(now.timestamp())
device_product_key = device[CONF_PRODUCT_KEY]
device_name = device[CONF_DEVICE_NAME]
device_secret = device[CONF_DEVICE_SECRET]
device_client_id = "%s&&&%s" % (device_product_key, device_name)
device_sign_content = "clientId%sdeviceName%sproductKey%stimestamp%d" % (device_client_id, device_name, device_product_key, timestamp)
device_sign = make_hmacsha1_hexdigest(device_secret, device_sign_content)
return [device_client_id, device_sign, timestamp]
def __init__(self, session, ip_address):
"""Initialize the data object."""
self._session = session
self._ip_address = ip_address
self._data = None
self._sensors = set()
self._day = dt_now().day
self._hour = dt_now().hour
self._month = dt_now().month
self._latest_call = time.time()
self._latest_pv_power = 0
self._latest_grid_power = 0
self._latest_house_power = 0
self._pv_energy_hour = 0
self._pv_energy_month = 0
self._grid_energy_hour = 0
self._grid_energy_today = 0
self._grid_energy_month = 0
self._grid_energy_total = 0
self._house_energy_hour = 0
self._house_energy_today = 0
self._house_energy_month = 0
self._house_energy_total = 0
self._grid_returned_energy_hour = 0
self._grid_returned_energy_today = 0
self._grid_returned_energy_month = 0
self._grid_returned_energy_total = 0
self._balance_neto_hour = 0
self._balance_neto_today = 0
self._balance_neto_month = 0
self._balance_neto_total = 0
def flux_update(self, now=None):
"""Update all the lights using flux."""
if now is None:
now = dt_now()
sunset = get_astral_event_date(self.hass, 'sunset', now.date())
start_time = self.find_start_time(now)
stop_time = now.replace(hour=self._stop_time.hour,
minute=self._stop_time.minute,
second=0)
if stop_time <= start_time:
# stop_time does not happen in the same day as start_time
if start_time < now:
# stop time is tomorrow
stop_time += datetime.timedelta(days=1)
elif now < start_time:
# stop_time was yesterday since the new start_time is not reached
stop_time -= datetime.timedelta(days=1)
if start_time < now < sunset:
# Daytime
time_state = 'day'
temp_range = abs(self._start_colortemp - self._sunset_colortemp)
day_length = int(sunset.timestamp() - start_time.timestamp())
seconds_from_start = int(now.timestamp() - start_time.timestamp())
percentage_complete = seconds_from_start / day_length
temp_offset = temp_range * percentage_complete
if self._start_colortemp > self._sunset_colortemp:
temp = self._start_colortemp - temp_offset
else:
temp = self._start_colortemp + temp_offset
else:
# Nightime
time_state = 'night'
if now < stop_time:
if stop_time < start_time and stop_time.day == sunset.day:
# we need to use yesterday's sunset time
sunset_time = sunset - datetime.timedelta(days=1)
else:
sunset_time = sunset
# pylint: disable=no-member
night_length = int(stop_time.timestamp() -
sunset_time.timestamp())
seconds_from_sunset = int(now.timestamp() -
sunset_time.timestamp())
percentage_complete = seconds_from_sunset / night_length
else:
percentage_complete = 1
temp_range = abs(self._sunset_colortemp - self._stop_colortemp)
temp_offset = temp_range * percentage_complete
if self._sunset_colortemp > self._stop_colortemp:
temp = self._sunset_colortemp - temp_offset
else:
temp = self._sunset_colortemp + temp_offset
rgb = color_temperature_to_rgb(temp)
x_val, y_val, b_val = color_RGB_to_xy(*rgb)
brightness = self._brightness if self._brightness else b_val
if self._disable_brightness_adjust:
brightness = None
if self._mode == MODE_XY:
set_lights_xy(self.hass, self._lights, x_val, y_val, brightness)
_LOGGER.info(
"Lights updated to x:%s y:%s brightness:%s, %s%% "
"of %s cycle complete at %s", x_val, y_val, brightness,
round(percentage_complete * 100), time_state, now)
elif self._mode == MODE_RGB:
set_lights_rgb(self.hass, self._lights, rgb)
_LOGGER.info(
"Lights updated to rgb:%s, %s%% "
"of %s cycle complete at %s", rgb,
round(percentage_complete * 100), time_state, now)
else:
# Convert to mired and clamp to allowed values
mired = color_temperature_kelvin_to_mired(temp)
set_lights_temp(self.hass, self._lights, mired, brightness)
_LOGGER.info(
"Lights updated to mired:%s brightness:%s, %s%% "
"of %s cycle complete at %s", mired, brightness,
round(percentage_complete * 100), time_state, now)
def flux_update(self, now=None):
"""Update all the lights using flux."""
if now is None:
now = dt_now()
sunset = get_astral_event_date(self.hass, 'sunset', now.date())
start_time = self.find_start_time(now)
stop_time = self.find_stop_time(now)
if stop_time <= start_time:
# stop_time does not happen in the same day as start_time
if start_time < now:
# stop time is tomorrow
stop_time += datetime.timedelta(days=1)
elif now < start_time:
# stop_time was yesterday since the new start_time is not reached
stop_time -= datetime.timedelta(days=1)
if start_time < now < sunset:
# Daytime
time_state = 'day'
temp_range = abs(self._start_colortemp - self._sunset_colortemp)
day_length = int(sunset.timestamp() - start_time.timestamp())
seconds_from_start = int(now.timestamp() - start_time.timestamp())
percentage_complete = seconds_from_start / day_length
temp_offset = temp_range * percentage_complete
if self._start_colortemp > self._sunset_colortemp:
temp = self._start_colortemp - temp_offset
else:
temp = self._start_colortemp + temp_offset
else:
# Night time
time_state = 'night'
if now < stop_time:
if stop_time < start_time and stop_time.day == sunset.day:
# we need to use yesterday's sunset time
sunset_time = sunset - datetime.timedelta(days=1)
else:
sunset_time = sunset
# pylint: disable=no-member
night_length = int(stop_time.timestamp() -
sunset_time.timestamp())
seconds_from_sunset = int(now.timestamp() -
sunset_time.timestamp())
percentage_complete = seconds_from_sunset / night_length
else:
percentage_complete = 1
temp_range = abs(self._sunset_colortemp - self._stop_colortemp)
temp_offset = temp_range * percentage_complete
if self._sunset_colortemp > self._stop_colortemp:
temp = self._sunset_colortemp - temp_offset
else:
temp = self._sunset_colortemp + temp_offset
rgb = color_temperature_to_rgb(temp)
x_val, y_val, b_val = color_RGB_to_xy_brightness(*rgb)
brightness = self._brightness if self._brightness else b_val
if self._disable_brightness_adjust:
brightness = None
if self._mode == MODE_XY:
set_lights_xy(self.hass, self._lights, x_val,
y_val, brightness, self._transition)
_LOGGER.info("Lights updated to x:%s y:%s brightness:%s, %s%% "
"of %s cycle complete at %s", x_val, y_val,
brightness, round(
percentage_complete * 100), time_state, now)
elif self._mode == MODE_RGB:
set_lights_rgb(self.hass, self._lights, rgb, self._transition)
_LOGGER.info("Lights updated to rgb:%s, %s%% "
"of %s cycle complete at %s", rgb,
round(percentage_complete * 100), time_state, now)
else:
# Convert to mired and clamp to allowed values
mired = color_temperature_kelvin_to_mired(temp)
set_lights_temp(self.hass, self._lights, mired, brightness,
self._transition)
_LOGGER.info("Lights updated to mired:%s brightness:%s, %s%% "
"of %s cycle complete at %s", mired, brightness,
round(percentage_complete * 100), time_state, now)
def calc_percent(self):
now = dt_now(self.data['timezone'])
_LOGGER.debug("now: " + str(now))
today_sun_times = self.get_sunrise_sunset(now)
_LOGGER.debug("today_sun_times: " + str(today_sun_times))
# Convert everything to epoch timestamps for easy calculation
now_seconds = now.timestamp()
sunrise_seconds = today_sun_times[SUN_EVENT_SUNRISE].timestamp()
sunset_seconds = today_sun_times[SUN_EVENT_SUNSET].timestamp()
solar_noon_seconds = today_sun_times['solar_noon'].timestamp()
solar_midnight_seconds = today_sun_times['solar_midnight'].timestamp()
if now < today_sun_times[
SUN_EVENT_SUNRISE]: # It's before sunrise (after midnight)
# Because it's before sunrise (and after midnight) sunset must have happend yesterday
yesterday_sun_times = self.get_sunrise_sunset(now -
timedelta(days=1))
_LOGGER.debug("yesterday_sun_times: " + str(yesterday_sun_times))
sunset_seconds = yesterday_sun_times[SUN_EVENT_SUNSET].timestamp()
if today_sun_times['solar_midnight'] > today_sun_times[
SUN_EVENT_SUNSET] and yesterday_sun_times[
'solar_midnight'] > yesterday_sun_times[
SUN_EVENT_SUNSET]:
# Solar midnight is after sunset so use yesterdays's time
solar_midnight_seconds = yesterday_sun_times[
'solar_midnight'].timestamp()
elif now > today_sun_times[
SUN_EVENT_SUNSET]: # It's after sunset (before midnight)
# Because it's after sunset (and before midnight) sunrise should happen tomorrow
tomorrow_sun_times = self.get_sunrise_sunset(now +
timedelta(days=1))
_LOGGER.debug("tomorrow_sun_times: " + str(tomorrow_sun_times))
sunrise_seconds = tomorrow_sun_times[SUN_EVENT_SUNRISE].timestamp()
if today_sun_times['solar_midnight'] < today_sun_times[
SUN_EVENT_SUNRISE] and tomorrow_sun_times[
'solar_midnight'] < tomorrow_sun_times[
SUN_EVENT_SUNRISE]:
# Solar midnight is before sunrise so use tomorrow's time
solar_midnight_seconds = tomorrow_sun_times[
'solar_midnight'].timestamp()
_LOGGER.debug("now_seconds: " + str(now_seconds))
_LOGGER.debug("sunrise_seconds: " + str(sunrise_seconds))
_LOGGER.debug("sunset_seconds: " + str(sunset_seconds))
_LOGGER.debug("solar_midnight_seconds: " + str(solar_midnight_seconds))
_LOGGER.debug("solar_noon_seconds: " + str(solar_noon_seconds))
# Figure out where we are in time so we know which half of the parabola to calculate
# We're generating a different sunset-sunrise parabola for before and after solar midnight
# because it might not be half way between sunrise and sunset
# We're also (obviously) generating a different parabola for sunrise-sunset
# sunrise-sunset parabola
if now_seconds > sunrise_seconds and now_seconds < sunset_seconds:
h = solar_noon_seconds
k = 100
# parabola before solar_noon
if now_seconds < solar_noon_seconds:
x = sunrise_seconds
# parabola after solar_noon
else:
x = sunset_seconds
y = 0
# sunset_sunrise parabola
elif now_seconds > sunset_seconds and now_seconds < sunrise_seconds:
h = solar_midnight_seconds
k = -100
# parabola before solar_midnight
if now_seconds < solar_midnight_seconds:
x = sunset_seconds
# parabola after solar_midnight
else:
x = sunrise_seconds
y = 0
a = (y - k) / (h - x)**2
percentage = a * (now_seconds - h)**2 + k
_LOGGER.debug("h: " + str(h))
_LOGGER.debug("k: " + str(k))
_LOGGER.debug("x: " + str(x))
_LOGGER.debug("y: " + str(y))
_LOGGER.debug("a: " + str(a))
_LOGGER.debug("percentage: " + str(percentage))
return percentage
def calc_percent(self):
now = dt_now()
today_sun_times = self.get_sunrise_sunset()
now_seconds = now.timestamp()
today_sunrise_seconds = today_sun_times['sunrise'].timestamp()
today_sunset_seconds = today_sun_times['sunset'].timestamp()
today_solar_noon_seconds = today_sun_times['solar_noon'].timestamp()
today_solar_midnight_seconds = today_sun_times[
'solar_midnight'].timestamp()
if now < today_sun_times['sunrise']:
yesterday_sun_times = self.get_sunrise_sunset(now -
timedelta(days=1))
yesterday_sunrise_seconds = yesterday_sun_times[
'sunrise'].timestamp()
yesterday_sunset_seconds = yesterday_sun_times['sunset'].timestamp(
)
yesterday_solar_midnight_seconds = yesterday_sun_times[
'solar_midnight'].timestamp()
x1 = yesterday_sunset_seconds
y1 = 0
if today_sun_times['solar_midnight'] > yesterday_sun_times[
'sunset'] and today_sun_times[
'solar_midnight'] < today_sun_times['sunrise']:
x2 = today_solar_midnight_seconds
else:
x2 = yesterday_solar_midnight_seconds
y2 = -100
x3 = today_sunrise_seconds
y3 = 0
elif now > today_sun_times['sunset']:
tomorrow_sun_times = self.get_sunrise_sunset(now +
timedelta(days=1))
tomorrow_sunrise_seconds = tomorrow_sun_times['sunrise'].timestamp(
)
tomorrow_sunset_seconds = tomorrow_sun_times['sunset'].timestamp()
tomorrow_solar_midnight_seconds = tomorrow_sun_times[
'solar_midnight'].timestamp()
x1 = today_sunset_seconds
y1 = 0
if today_sun_times['solar_midnight'] > today_sun_times[
'sunset'] and today_sun_times[
'solar_midnight'] < tomorrow_sun_times['sunrise']:
x2 = today_solar_midnight_seconds
else:
x2 = tomorrow_solar_midnight_seconds
y2 = -100
x3 = tomorrow_sunrise_seconds
y3 = 0
else:
x1 = today_sunrise_seconds
y1 = 0
x2 = today_solar_noon_seconds
y2 = 100
x3 = today_sunset_seconds
y3 = 0
# Generate color temperature parabola from points
a1 = -x1**2 + x2**2
b1 = -x1 + x2
d1 = -y1 + y2
a2 = -x2**2 + x3**2
b2 = -x2 + x3
d2 = -y2 + y3
bm = -(b2 / b1)
a3 = bm * a1 + a2
d3 = bm * d1 + d2
a = d3 / a3
b = (d1 - a1 * a) / b1
c = y1 - a * x1**2 - b * x1
percentage = a * now_seconds**2 + b * now_seconds + c
return percentage
async def async_push_indications(
self,
indications: List[Union[str, SupportsFloat]],
force: bool = False,
service_type: Optional[str] = None,
dry_run: bool = False,
) -> None:
error = None
pass_indications = None
try:
if isinstance(self.service_type, str):
if service_type is None:
service_type = self.service_type
elif service_type != self.service_type:
raise ValueError(
'Incorrect service type provided (expected: "%s", got: "%s"'
% (self.service_type, service_type)
)
elif service_type is None:
raise ValueError(
"Service type not defined for multi-service-type indications entity"
)
elif service_type not in self.service_type:
raise ValueError(
'Incorrect service type provided (expected: %s, got: "%s")'
% (self.service_type, service_type)
)
if not indications:
raise ValueError("Indications are empty")
indications_count = await self.async_get_indications_count(service_type, force)
if indications_count is not None:
if isinstance(indications_count, int):
if indications_count != len(indications):
raise ValueError(
"Invalid indications count provided (expected: %d, got: %d)"
% (indications_count, len(indications))
)
elif len(indications) not in range(indications_count[0], indications_count[1] + 1):
raise ValueError(
"Invalid indications count provided (expected: %d <= N <= %d, got: %d)"
% (indications_count[0], indications_count[1], len(indications))
)
pass_indications = []
state_machine = self.hass.states
for indication in indications:
if isinstance(indication, str):
state = state_machine.get(indication)
if state is None:
raise ValueError(
'Could not retrieve state for entity with ID "%s"' % (indication,)
)
indication = state.state
pass_indications.append(
float(indication)
) # will raise ValueError if non-floatable type
await self._async_push_indications(pass_indications, force, service_type, dry_run)
except Exception as e:
error = e
raise
finally:
event_data_dict = {
ATTR_TIME: dt_now().isoformat(),
ATTR_ENTITY_ID: self.entity_id,
ATTR_SERVICE_TYPE: service_type,
ATTR_INDICATIONS: pass_indications,
ATTR_ORIGINAL_INDICATIONS: indications,
ATTR_DRY_RUN: dry_run,
ATTR_SUCCESS: not error,
}
if error:
event_data_dict[ATTR_REASON] = str(error)
update_dict = await self.async_get_indications_event_data_dict(
indications=pass_indications or indications, force=force, service_type=service_type
)
if update_dict:
event_data_dict.update(update_dict)
self.hass.bus.async_fire(
event_type=EVENT_FORMAT_INDICATIONS_PUSH % (service_type,),
event_data=event_data_dict,
)
async def _update(self):
"""Get the latest data from inverter."""
_LOGGER.debug("-->{}s {}(PowerflowData) ({}:{})".format(
round(time.time() - start_time, 3),
inspect.currentframe().f_code.co_name, os.path.basename(__file__),
inspect.currentframe().f_lineno))
self._data = (await self.fetch_data(self._build_url()))['Body']['Data']
current_time = time.time()
elapsed = int(round(current_time - self._latest_call))
pv_energy_elapsed = self._latest_pv_power * elapsed
grid_energy_elapsed = self._latest_grid_power * elapsed
house_energy_elapsed = self._latest_house_power * elapsed
self._balance_neto_hour -= grid_energy_elapsed
self._pv_energy_hour += pv_energy_elapsed
self._pv_energy_month += pv_energy_elapsed
if self._latest_grid_power > 0:
self._grid_energy_hour += grid_energy_elapsed
self._grid_energy_today += grid_energy_elapsed
self._grid_energy_month += grid_energy_elapsed
self._grid_energy_total += grid_energy_elapsed
else:
self._grid_returned_energy_hour -= grid_energy_elapsed
self._grid_returned_energy_today -= grid_energy_elapsed
self._grid_returned_energy_month -= grid_energy_elapsed
self._grid_returned_energy_total -= grid_energy_elapsed
# house_power is a negative number
if self._latest_house_power < 0:
self._house_energy_hour -= house_energy_elapsed
self._house_energy_today -= house_energy_elapsed
self._house_energy_month -= house_energy_elapsed
self._house_energy_total -= house_energy_elapsed
if self._data:
self._latest_pv_power = int(round(self._data['Site']['P_PV'])
) if self._data['Site']['P_PV'] else 0
self._latest_grid_power = int(round(self._data['Site']['P_Grid']))
self._latest_house_power = int(round(self._data['Site']['P_Load']))
self._latest_call = current_time
if dt_now().hour != self._hour:
self._hour = dt_now().hour
if self._grid_energy_hour > self._grid_returned_energy_hour:
self._balance_neto_today += self._grid_returned_energy_hour
self._balance_neto_month += self._grid_returned_energy_hour
self._balance_neto_total += self._grid_returned_energy_hour
else:
self._balance_neto_today += self._grid_energy_hour
self._balance_neto_month += self._grid_energy_hour
self._balance_neto_total += self._grid_energy_hour
self._balance_neto_hour = 0
self._pv_energy_hour = 0
self._grid_energy_hour = 0
self._house_energy_hour = 0
self._grid_returned_energy_hour = 0
if dt_now().day != self._day:
self._day = dt_now().day
self._balance_neto_today = 0
self._grid_energy_today = 0
self._house_energy_today = 0
self._grid_returned_energy_today = 0
if dt_now().month != self._month:
self._month = dt_now().month
self._balance_neto_month = 0
self._pv_energy_month = 0
self._grid_energy_month = 0
self._house_energy_month = 0
self._grid_returned_energy_month = 0
_LOGGER.debug("<--{}s {}(PowerflowData) ({}:{})".format(
round(time.time() - start_time, 3),
inspect.currentframe().f_code.co_name, os.path.basename(__file__),
inspect.currentframe().f_lineno))
def flux_force_update(self, call=None, entity=None):
"""Forced update of given or all the lights using flux."""
now = dt_now()
if call is None:
if entity is None:
entity_id = self._lights
else:
entity_id = entity
else:
entity_id = call.data.get("entity_id", self._lights)
_LOGGER.info("Flux forced update for %s",
entity_id)
sunset = get_astral_event_date(self.hass, 'sunset', now.date())
start_time = self.find_start_time(now)
stop_time = now.replace(
hour=self._stop_time.hour, minute=self._stop_time.minute,
second=0)
if stop_time <= start_time:
# stop_time does not happen in the same day as start_time
if start_time < now:
# stop time is tomorrow
stop_time += datetime.timedelta(days=1)
elif now < start_time:
# stop_time was yesterday since the new start_time is not reached
stop_time -= datetime.timedelta(days=1)
if start_time < now < sunset:
# Daytime
time_state = 'day'
temp_range = abs(self._start_colortemp - self._sunset_colortemp)
day_length = int(sunset.timestamp() - start_time.timestamp())
seconds_from_start = int(now.timestamp() - start_time.timestamp())
percentage_complete = seconds_from_start / day_length
temp_offset = temp_range * percentage_complete
if self._start_colortemp > self._sunset_colortemp:
temp = self._start_colortemp - temp_offset
else:
temp = self._start_colortemp + temp_offset
else:
# Nightime
time_state = 'night'
if now < stop_time:
if stop_time < start_time and stop_time.day == sunset.day:
# we need to use yesterday's sunset time
sunset_time = sunset - datetime.timedelta(days=1)
else:
sunset_time = sunset
# pylint: disable=no-member
night_length = int(stop_time.timestamp() -
sunset_time.timestamp())
seconds_from_sunset = int(now.timestamp() -
sunset_time.timestamp())
percentage_complete = seconds_from_sunset / night_length
else:
percentage_complete = 1
temp_range = abs(self._sunset_colortemp - self._stop_colortemp)
temp_offset = temp_range * percentage_complete
if self._sunset_colortemp > self._stop_colortemp:
temp = self._sunset_colortemp - temp_offset
else:
temp = self._sunset_colortemp + temp_offset
rgb = color_temperature_to_rgb(temp)
x_val, y_val, b_val = color_RGB_to_xy(*rgb)
brightness = self._brightness if self._brightness else b_val
if self._mode == MODE_XY:
_LOGGER.debug("Trying to force update of %s to XY %s, %s", entity_id, x_val, y_val)
force_light_xy(self.hass, entity_id, x_val,
y_val, brightness)
new_color_xy = set_lights_xy(self.hass, self._lights, x_val,
y_val, brightness, self._transition, self._last_color)
_LOGGER.info("Lights updated to x:%s y:%s brightness:%s, %s%% "
"of %s cycle complete at %s", x_val, y_val,
brightness, round(
percentage_complete * 100), time_state, now)
self._last_color = new_color_xy
elif self._mode == MODE_RGB:
force_light_rgb(self.hass, entity_id, rgb)
new_color_rgb = set_lights_rgb(self.hass, self._lights, rgb, self._transition, self._last_color)
_LOGGER.info("Lights updated to rgb:%s, %s%% "
"of %s cycle complete at %s", rgb,
round(percentage_complete * 100), time_state, now)
self._last_color = new_color_rgb
else:
# Convert to mired and clamp to allowed values
mired = color_temperature_kelvin_to_mired(temp)
_LOGGER.debug("Trying to force update of %s to mired %s", entity_id, mired)
force_light_temp(self.hass, entity_id, mired, brightness)
new_colortemp = set_lights_temp(self.hass, self._lights, mired, brightness,
self._transition, self._last_color)
_LOGGER.info("Lights updated from %s to mired:%s brightness:%s, %s%% "
"of %s cycle complete at %s", self._last_color, mired, brightness,
round(percentage_complete * 100), time_state, now)
self._last_color = new_colortemp
