def main():
loop = asyncio.get_event_loop()
local_sun = Sun(config.LATITUDE, config.LONGITUDE)
today_datetime = datetime.datetime.now(tz=pytz.utc)
sunrise_datetime = local_sun.get_sunrise_time(today_datetime.date())
sunset_datetime = local_sun.get_sunset_time(today_datetime.date())
while True:
# If sunrise has already passed, get the next sunrise
if sunrise_datetime < today_datetime:
sunrise_datetime = local_sun.get_sunrise_time(
today_datetime.date() + datetime.timedelta(1))
# If sunset is sooner than the sunrise
if sunset_datetime < sunrise_datetime:
print("Sunset is soonest, pausing")
pause_until(sunset_datetime)
# pause.until(sunset_datetime)
loop.run_until_complete(led_on())
sunset_datetime = local_sun.get_sunset_time(today_datetime.date() +
datetime.timedelta(1))
# Launch wallpaper monitor here
if sunrise_datetime < sunset_datetime:
print("Sunrise is soonest, pausing")
pause_until(sunrise_datetime)
# pause.until(sunrise_datetime)
loop.run_until_complete(led_off())
sunrise_datetime = local_sun.get_sunset_time(
today_datetime.date() + datetime.timedelta(1))
def update_sun_times():
try:
sun = Sun(latitude, longitude)
sunrise = sun.get_sunrise_time()
sunset = sun.get_sunset_time()
# Version for machine's local time
# sunrise = sun.get_local_sunrise_time()
# sunset = sun.get_local_sunset_time()
light_turnOn = sunset + timedelta(minutes=20)
light_turnOn_time = time(light_turnOn.hour,
light_turnOn.minute,
tzinfo=tz.tzutc())
light_turnOff = sunrise + timedelta(minutes=30)
light_turnOff_time = time(light_turnOff.hour,
light_turnOff.minute,
tzinfo=tz.tzutc())
if (manualMode == True):
if debug:
print(
"=== Sun times acquired, switching to sunrise/sunset mode ==="
)
manualMode = False
elif (manualMode == False):
if debug:
print("=== Sun times updated ===")
return True
except SunTimeException as e:
if debug:
print("SunTime failed. Error: {0}.".format(e))
print("!!! SWITCHING TO MANUAL TIME MODE !!!")
manualMode = True
return False
def change_mode(self):
sun = Sun(self.latitude, self.longitude)
sunrise = '''
tell application "System Events"
tell appearance preferences
set dark mode to false
end tell
end tell
'''
sunset = '''
tell application "System Events"
tell appearance preferences
set dark mode to true
end tell
end tell
'''
p = Popen(['osascript', '-'],
stdin=PIPE,
stdout=PIPE,
stderr=PIPE,
universal_newlines=True)
today_sr = (sun.get_sunrise_time() -
datetime.timedelta(hours=16)).strftime('%Y-%m-%d %H:%M')
today_ss = (sun.get_sunset_time() +
datetime.timedelta(hours=8)).strftime('%Y-%m-%d %H:%M')
print(today_sr, today_ss)
# 获取当前时间
now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M')
# 白天（不需要开暗黑模式）
if today_sr < now < today_ss:
p.communicate(sunrise)
else:
p.communicate(sunset)
return
class Suntime:
# magic!
OFFSET = timedelta(minutes=30)
def __init__(self, location, logger):
self.logger = logger
self.sun = None
if location is not None:
self.sun = Sun(location[0], location[1])
def sunset(self, cur_date):
sunset = self.sun.get_sunset_time(cur_date)
return sunset - Suntime.OFFSET
def sunrise(self, cur_date):
sunrise = self.sun.get_sunrise_time(cur_date)
return sunrise + Suntime.OFFSET
def is_night(self, cur_date):
if self.sun is None:
return False
sunrise = self.sunrise(cur_date)
sunset = self.sunset(cur_date)
if sunrise > sunset:
if sunset <= cur_date <= sunrise:
return True
else:
if sunrise <= cur_date <= sunset:
return True
def get_suntimes(date, latitude=47.26, longitude=11.39):
sun = Sun(latitude, longitude)
# Get today's sunrise and sunset in UTC
today_sr = sun.get_sunrise_time(date)
today_ss = sun.get_sunset_time(date)
return ({'sunrise': today_sr, 'sunset': today_ss})
def main():
print("LED Controller Starting...")
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(18, GPIO.OUT)
GPIO.output(18, GPIO.HIGH)
while True:
sun = Sun(latitude, longitude)
sunrise = sun.get_sunrise_time()
sunset = sun.get_sunset_time()
print(sunrise)
print(sunset)
t = datetime.now(timezone.utc)
print(t)
seven_am = datetime.now(timezone.utc).replace(hour=6,
minute=0,
second=0,
microsecond=0)
if seven_am < t < sunset:
print("Time is greater than sunrise but less than sunset")
GPIO.output(18, GPIO.HIGH)
else:
print("Before Sunrise or after Sunset")
GPIO.output(18, GPIO.LOW)
time.sleep(60)
def getSunsetTime(when=None):
s = Sun(lat,lon)
if when is None:
when = datetime.datetime.now()
sunsetToday = s.get_sunset_time(when)
sunsetToday = sunsetToday + datetime.timedelta(days=1)# library has off by 1 day, unsure why ? ( known issue? )
print(f'Next sunset at: {sunsetToday.strftime('%m/%d/%y %H:%M')}')
return sunsetToday
def is_day(self):
sun = Sun(self.lat, self.lng)
sunrise, sunset = sun.get_sunrise_time(), sun.get_sunset_time()
if sunset < sunrise:
sunset += timedelta(days=1)
now = datetime.now(timezone.utc)
return (sunrise < now < sunset
or sunrise < now + timedelta(days=1) < sunset
or sunrise < now + timedelta(days=-1) < sunset)
def generate_pv_output(dt: datetime) -> int:
"""Wrapper to generate PV output.
This gets the sunrise/sunset times for a given location
and then invokes the actual PV calculation if the given datetime is inbetween the two times.
If the given datetime is not between sunrise and sunset, 0 is returned instead.
"""
sun = Sun(LATITUDE, LONGITUDE)
sunrise = sun.get_sunrise_time()
sunset = sun.get_sunset_time()
if not is_sunny(dt, sunrise, sunset):
return 0
return calculate_pv_output(dt, sunrise, sunset)
async def run_timed_events(self):
await self.wait_until_ready()
if len(self.settings.behaviors.timed) == 0:
return
latitude = float(os.getenv('LOCAL_LATITUDE'))
longitude = float(os.getenv('LOCAL_LONGITUDE'))
sun = Sun(latitude, longitude)
while True:
now = datetime.now()
sunrise = utc_to_local(sun.get_sunrise_time()).replace(tzinfo=None)
sunset = utc_to_local(sun.get_sunset_time()).replace(tzinfo=None)
timed_events = []
for t in self.settings.behaviors.timed:
if t.type == 'daily':
target_time = now.replace(hour=t.time[0],
minute=t.time[1],
second=0)
elif t.type == 'sunrise':
target_time = sunrise - timedelta(
seconds=t.minutes_before * 60)
elif t.type == 'sunset':
target_time = sunset - timedelta(seconds=t.minutes_before *
60)
while target_time < now:
target_time += timedelta(days=1)
timed_events.append({'event': t, 'time': target_time})
timed_events = sorted(timed_events, key=lambda k: k['time'])
next_event = timed_events[0]
channel_id = next_event['event'].channel
program_idx = next_event[
'event'].program_index if 'program_index' in next_event[
'event'] else 0
time_until = next_event['time'] - now
print('time until next event: {}'.format(time_until))
await asyncio.sleep(time_until.seconds)
await self.run_program(next_event['event'].program,
data=None,
channel=self.get_channel(channel_id),
program_idx=program_idx)
await asyncio.sleep(60)
def sun_rise_set(latitude, longitude, abd, TZ="UTC"):
sun = Sun(latitude, longitude)
if (TZ == "UTC"):
today_sr = sun.get_sunrise_time()
today_ss = sun.get_sunset_time()
if DBG:
print(
'Today at {2[0]}°{2[1]}\'{2[2]:2.2f}"N {2[3]}°{2[4]}\'{2[5]:2.2f}"E the sun raised at {0} and get down at {1} UTC'
.format(today_sr.strftime('%H:%M:%S'),
today_ss.strftime('%H:%M:%S'),
coord(latitude, longitude)))
return today_sr, today_ss
else:
abd_sr = sun.get_local_sunrise_time(abd)
abd_ss = sun.get_local_sunset_time(abd)
if DBG:
print(
'On {0} the sun at {2[0]}°{2[1]}\'{2[2]:2.2f}\"N {2[3]}°{2[4]}\'{2[5]:2.2f}\"E raised at {1} and get down at {3}.'
.format(abd, abd_sr.strftime('%H:%M:%S'),
coord(latitude, longitude),
abd_ss.strftime('%H:%M:%S')))
return abd_sr, abd_ss
def index(lat, lng):
obs = get_obs()
closest = sorted(obs,
key=lambda o: calc_distance(float(o[0][
'lat']), float(o[0]['lon']), lat, lng))[0]
stk = [x for x in obs if x[0]["stn_name"] == "ST KILDA HARBOUR - RMYS"]
if len(stk):
stk = {
"wind_spd_kt": stk[0][1]["wind_spd"],
"wind_dir": stk[0][1]["wind_dir"]
}
else:
stk = {"wind_spd_kt": "", "wind_dir": ""}
forecast = get_forecast()
sun = Sun(lat, lng)
sunr = sun.get_sunrise_time().timestamp()
sund = sun.get_sunset_time().timestamp()
return json.dumps({
"closest": {
"stn":
closest[0]["description"],
"wind_dir":
closest[1]["wind_dir"],
"wind_spd_kt":
closest[1]["wind_spd"],
"app_tmp":
closest[1]["apparent_temp"],
"rel_humidity":
closest[1]["rel_humidity"],
"ts":
round(
datetime.datetime.strptime(closest[1]["datetime"],
"%Y-%m-%dT%H:%M:%S%z").timestamp()),
},
"srss": [round(sunr), round(sund)],
"stk": stk,
"forecast": forecast,
})
def get_timezone(latitude, longitude):
#Get today sunrise and sunset
sun = Sun(latitude, longitude)
today_sr = int(sun.get_sunrise_time().strftime('%H'))
today_ss = int(sun.get_sunset_time().strftime('%H'))
#Get timezone
tf = TimezoneFinder()
timezone = tf.timezone_at(lng=longitude, lat=latitude) # returns 'Europe/Berlin'
#Get time
tz = pytz.timezone(timezone)
timezone_now = int(datetime.datetime.now(tz).strftime('%H'))
logging.info(str(timezone_now))
logging.info(str(today_sr))
logging.info(str(today_ss))
if timezone_now > today_sr and timezone_now < today_ss:
day = "Day"
else:
day = "Night"
return day
# Thanks to this S.O question: https://es.stackoverflow.com/questions/387503/importerror-cannot-import-name-sun-from-suntime/387572
# We need suntime module: pip3 install suntime
import datetime
# Import suntime:
from suntime import Sun, SunTimeException
# Define latitude and longitude:
latitud = 43.36
longitud = -8.41
# Sun instance
sun = Sun(latitud, longitud)
# Set today's sunrise
hoy_sr = sun.get_sunrise_time()
# Set today's sunset
hoy_ss = sun.get_sunset_time()
# Print with format
print('Hoy el sol en Galicia salió a las {} y baja a las {}'.format(
hoy_sr.strftime('%H:%M'), hoy_ss.strftime('%H:%M')))
# Result:
# Hoy el sol en Galicia salió a las 06:03 y baja a las 19:01
bomba = 23
# GPIO setup
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(bomba, GPIO.OUT)
# coordenadas Covilhã
latitude = 40.28
longitude = -7.50
utc = pytz.utc
sun = Sun(latitude, longitude)
nascerSol = sun.get_sunrise_time()
porSol = sun.get_sunset_time()
#horario de verao
now = datetime.now().replace(tzinfo=utc)
dia = now.day
mes = now.month
hoje = (mes, dia)
iniVerao = (3, 29)
fimVerao = (10, 25)
if iniVerao < hoje < fimVerao:
nascerSol = nascerSol + timedelta(hours=1)
porSol = porSol + timedelta(hours=1)
print("Agora: ", str(now))
print("Nascer hoje: ", str(nascerSol))
import datetime
from suntime import Sun, SunTimeException
# Lyon
latitude = 45.75
longitude = 4.85
sun = Sun(latitude, longitude)
# Get today's sunrise and sunset in UTC
today_sr = sun.get_sunrise_time()
today_ss = sun.get_sunset_time()
print('Today at Lyon the sun raised at {} and get down at {} UTC'.format(
today_sr.strftime('%H:%M'), today_ss.strftime('%H:%M')))
# On a special date in your machine's local time zone
abd = datetime.date(2020, 9, 25)
abd_sr = sun.get_local_sunrise_time(abd)
abd_ss = sun.get_local_sunset_time(abd)
print(
'On {} the sun at Lyon raised at {} and get down at {}. local time'.format(
abd, abd_sr.strftime('%H:%M'), abd_ss.strftime('%H:%M')))
class SolarPower:
def __init__(self):
#Solar Array Data
self.itemCode = "ALTS-200W-24P"
self.solarPanelEfficiency = 0.1572 #Prosent
self.solarPanelMinTemp = -40 # Celsius
self.solarPanelMaxTemp = 80 # Celsius
self.solarPanelPower = 4864 # W
self.solarPanelArea = 32 # m^2
self.powersqm = 153 #W/m^2
# Constants
self.solarIridiationConstant = 1367 #W/m^2
self.solarPanelMaxCloudLoss = 0.30 # prosent
self.lat = 63.42
self.lon = 10.40
self.city = "Trondheim"
self.sun = Sun(self.lat, self.lon)
#data
self.weatherData = self.getWeatherDataFromFile()
#Weather Data
self.key = "8554bc4036b0ec568b136bbba124d344"
self.url = f"https://api.openweathermap.org/data/2.5/weather?lat={self.lat}&lon={self.lon}&appid={self.key}"
def getWeatherDataFromFile(self):
#data = pd.read_csv("weatherHistoryHourly.csv", dtype={"dt": "int64", "clouds_all":"int64"}, parse_dates=["dt_iso"])
data = pd.read_csv("newWeatherData.csv",
dtype={
"dt": "int64",
"clouds_all": "int64"
},
parse_dates=["dt_iso"])
return data
def getIridiationDataFromFile(self):
irridiationData = pd.read_csv("solarIridiation.csv",
dtype={"P": "float64"})
return irridiationData
def weatherCoefficient(self,
timestamp=None,
date=None,
row=None,
data=None):
if timestamp != None:
cloud_coverage = row = data.loc[data["dt"] == timestamp,
"clouds_all"]
cloudCoefficient = 1 - (self.solarPanelMaxCloudLoss *
cloud_coverage / 100)
return cloudCoefficient
elif date != None:
pass
elif row != None:
cloud_coverage = data["clouds_all"][row]
cloudCoefficient = 1 - (self.solarPanelMaxCloudLoss *
cloud_coverage / 100)
return cloudCoefficient
else:
return 1
return 1
def irradiationCoefficient(self, timestamp=None, data=None):
return 1
def powerCalculationHour(self, timestamp=None, row=None, data=None):
timestamp = data["dt"][row]
sunRise = self.sun.get_sunrise_time(
datetime.datetime.utcfromtimestamp(timestamp)).replace(tzinfo=None)
sunSet = self.sun.get_sunset_time(
datetime.datetime.utcfromtimestamp(timestamp)).replace(tzinfo=None)
dataTime = datetime.datetime.utcfromtimestamp(timestamp)
if sunRise < dataTime < sunSet:
return self.solarIridiationConstant * self.solarPanelEfficiency * self.weatherCoefficient(
row=row, data=data) * self.irradiationCoefficient()
else:
return 0
def updateHistoricSolarPowerGeneration(self):
data = self.getWeatherDataFromFile()
data.loc[:, "generated_solar_power[Wh]"] = 0.1
iri = self.getIridiationDataFromFile()
for i in range(len(data["dt"]) - 1):
timeC = datetime.datetime.utcfromtimestamp(
data["dt"][i]).strftime("%m%d%H%M")
series = iri.loc[iri["dateC"] == int(timeC), "P"]
try:
power = series.to_list()[0]
except:
timeC = datetime.datetime.utcfromtimestamp(
data["dt"][i - 1]).strftime("%m%d%H%M")
series = iri.loc[iri["dateC"] == int(timeC), "P"]
power = series.to_list()[0]
data.loc[i,
"generated_solar_power[Wh]"] = power * self.solarPanelArea
data.loc[:, "generated_solar_power[Wh]"].astype(float)
"""
for i in range(len(data["dt"])):
#data2["generated_solar_power[Wh]"][i] = self.powerCalculationHour(data["dt"][i])
data.loc[:,"generated_solar_power[Wh]"].iloc[i] = self.powerCalculationHour(row = i, data=data)
#print(f"{data['generated_solar_power[Wh]'][i]} = {self.powerCalculationHour(row = i)}")
"""
data.to_csv("newWeatherData.csv", index=False)
return data
def updateHistoricWeatherData(self):
oldWeatherData = self.getWeatherDataFromFile() # Get data
lastOldDataTimestamp = oldWeatherData.loc[:, "dt"].iloc[
len(oldWeatherData["dt"]) - 1] + 86400 # Last Timestamp
lastOldDataDate = datetime.datetime.utcfromtimestamp(
lastOldDataTimestamp) # Last Timestamp in datetime format
lastOldDataDay = lastOldDataDate.replace(hour=0) # Last timestamp day
currentDate = datetime.datetime.utcnow()
currentDateTimestamp = int(currentDate.timestamp())
deltatime = (currentDate - lastOldDataDay)
df = df2 = pd.DataFrame(columns=oldWeatherData.columns)
for days in range(deltatime.days):
if (deltatime.days - days) < 5:
timestamp = int(
(lastOldDataDay +
datetime.timedelta(days=days)).timestamp()) + 7200
data = self.getHistoricWeatherDataFromTimestamp(timestamp)
df2 = pd.DataFrame(
data["hourly"]).rename(columns={"clouds": "clouds_all"})
df = df.append(df2).reset_index(drop=True)
else:
yesterdayTimestamp = int(
(lastOldDataDay + datetime.timedelta(days=deltatime.days) -
datetime.timedelta(days=1)).timestamp())
data = self.getHistoricWeatherDataFromTimestamp(
yesterdayTimestamp)
df2 = pd.DataFrame(
data["hourly"]).rename(columns={"clouds": "clouds_all"})
timestamp = int((lastOldDataDay +
datetime.timedelta(days=days)).timestamp() +
7200)
#return lastOldDataDay
for n in range(len(df2["dt"])):
df2["dt"][n] = timestamp + 3600 * n
df = df.append(df2).reset_index(drop=True)
df.loc[:, "dt"] = pd.to_numeric(df["dt"]).astype(int)
for i in range(len(df["dt"])):
df.loc[:, "dt_iso"].iloc[i] = str(
datetime.datetime.utcfromtimestamp(df["dt"][i])) + " +0000 UTC"
newWeatherData = oldWeatherData.append(df)
newWeatherData.to_csv("newWeatherData.csv", index=False)
return (df)
def getHistoricWeatherDataFromTimestamp(self, timestamp):
hUrl = f"http://api.openweathermap.org/data/2.5/onecall/timemachine?lat={self.lat}&lon={self.lon}&dt={timestamp}&appid={self.key}"
get = requests.get(hUrl)
hWeather = json.loads(get.content)
return hWeather
def getWeatherNow(self):
get = requests.get(self.url)
data = json.loads(get.content)
return data
def getSolarPowerNow(self):
data = self.getWeatherNow()
cloudFactor = data["clouds"]["all"] / 100
sunRiseUnix = data["sys"]["sunrise"]
sunSetUnix = data["sys"]["sunset"]
systemSize = 6000 #W
maxCloudLoss = 0.30 #prosent
currentTimeUnix = time.time()
if currentTimeUnix > sunRiseUnix and currentTimeUnix < sunSetUnix:
return systemSize * (1 - maxCloudLoss * cloudFactor)
else:
return 0
nowTemp = dataControl.loc[hour, 'startTime']
if nowTemp.hour == 22 or nowTemp.hour == 23: # reduce ventilation when going to bed
dataControl.loc[hour, 'ventilation'] = True
if dataControl.loc[hour, 'waterTempIncrease']:
dataControl.loc[hour, 'ventilation'] = False
dataControl.loc[hour, 'compressor'] = True
dataControl.loc[hour, 'addHeating'] = True
# ensure that heating is allowed in initial programm start
if initial:
for hour in range(0, 2):
dataControl.loc[hour, 'compressor'] = True
dataControl.loc[hour, 'addHeating'] = True
dataControl.loc[hour, 'ventilation'] = False
sunrise = sun.get_sunrise_time() + dt.timedelta(hours=utcoffset)
sunset = sun.get_sunset_time() + dt.timedelta(hours=utcoffset)
# plot dashboard
# gererate axis label for for weather data
timeVecWeather = []
timeVecWeatherLabel = []
timeVecWeatherMinor = []
timeVecWeatherLabel = []
for hour in range(0, len(weatherData)):
a = weatherData.loc[hour, 'start_time']
if a.hour == 0:
timeVecWeather.append(hour)
timeVecWeatherLabel.append(
' ' + a.strftime('%a') + ' ' + a.strftime('%d') + '.' + a.strftime('%m') + '.')
if (weatherData.loc[hour, 'start_time'].hour / 3).is_integer():
timeVecWeatherMinor.append(hour)
def get_sunset(address, from_grid=True):
"""Get sunset quality and parse into message"""
# Load Sunburst API credentials
EMAIL = os.getenv("SUNBURST_EMAIL")
PASSWORD = os.getenv("SUNBURST_PW")
url = "https://sunburst.sunsetwx.com/v1/login"
# Get Sunburst API token via POST
res = requests.post(url, auth=(EMAIL, PASSWORD))
# res = requests.post(url, data=payload)
result = re.findall(r'token\":\"[0-9a-xA-Z-]*', res.text)
token = "Bearer " + result[0][8:]
# Get sunset quality via Sunburst GET
headers = {"Authorization": token}
url = "https://sunburst.sunsetwx.com/v1/quality"
# Return if invalid coords
coords = address_to_coord(address)
if coords == -1:
return "Invalid location. Please enter valid address."
total = 0
# Get coordinates and quality at each coord
coords_list = []
# If calculate quality from grid, false if calculate from single coord
if from_grid:
coords_list = generate_grid(coords)
if len(coords_list) == 0:
coords_list = [str(coords[0]) + "," + str(coords[1])]
else:
coords_list = [str(coords[0]) + "," + str(coords[1])]
for coord in coords_list:
data = {"geo": coord}
res = requests.get(url, headers=headers, params=data)
try:
quality_percent = re.findall(r'quality_percent\":\d*\.\d*',
res.text)[0][17:]
except:
return "Too many Sunburst requests. Try again later."
total += float(quality_percent)
quality_percent = total / float(len(coords_list))
quality = ""
if quality_percent < 25:
quality = "Poor"
elif quality_percent < 50:
quality = "Fair"
elif quality_percent < 75:
quality = "Good"
else:
quality = "Great"
# Get today's sunset in local time
sun = Sun(coords[0], coords[1])
today_ss = sun.get_sunset_time()
# Convert time zone
GEO_USERNAME = os.getenv("GEONAMES_USERNAME")
geolocator = GeoNames(username=GEO_USERNAME)
timezone = geolocator.reverse_timezone(coords)
from_zone = tz.gettz("UTC")
to_zone = tz.gettz(str(timezone))
today_ss = today_ss.replace(tzinfo=from_zone)
sunset_time = today_ss.astimezone(to_zone)
# Get day of week
day_list = [
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
"Sunday"
]
day = day_list[datetime.datetime.today().weekday()]
# Create message
message = "Quality: " + quality + " " + str(round(
quality_percent, 2)) + "%\nSunset at {}pm".format(
sunset_time.strftime("%H:%M")) + "\n\n" + day + " at " + address
return message
config.read('/home/pi/coop/coop.ini')
# logging
logging.basicConfig(filename=config['Settings']['LogFile'],
level=config['Settings']['LogLevel'],
format='%(asctime)s - %(levelname)s: %(message)s')
# Suntime
sun = Sun(float(config['Location']['Latitude']),
float(config['Location']['Longitude']))
now = (datetime.now(timezone.utc))
offset = int(config['Door']['Offset'])
doortime_open: int = int(config['Door']['Doortime_Open'])
doortime_close: int = int(config['Door']['Doortime_Close'])
opentime = sun.get_sunrise_time() - timedelta(minutes=offset)
closetime = sun.get_sunset_time() + timedelta(minutes=offset)
opentimetomorrow = sun.get_local_sunrise_time(datetime.now() +
timedelta(days=1) -
timedelta(minutes=offset))
closetimeyesterday = sun.get_local_sunset_time(datetime.now() + timedelta(
days=-1)) + timedelta(minutes=offset)
global stop_threads
# GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
TopSensor = int(config['GPIO']['TopSensor'])
BottomSensor = int(config['GPIO']['BottomSensor'])
GPIO.setup(TopSensor, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(BottomSensor, GPIO.IN, pull_up_down=GPIO.PUD_UP)
MotorUp = int(config['GPIO']['IN3'])
'AppsUseLightTheme', '/t', 'REG_DWORD', '/d', values[1], '/f'
]
windows = base + [
'WindowsUseLightTheme', '/t', 'REG_DWORD', '/d', values[2], '/f'
]
subprocess.run(system, stdout=subprocess.DEVNULL)
subprocess.run(apps, stdout=subprocess.DEVNULL)
subprocess.run(windows, stdout=subprocess.DEVNULL)
if __name__ == '__main__':
# prepare for theme
sun = Sun(45.4, 9.1)
sunrise = sun.get_sunrise_time().strftime('%H:%M:%S')
sunset = sun.get_sunset_time().strftime('%H:%M:%S')
do_light, do_dark = True, True
theme = {"light": ['1', '1', '0'], "dark": ['0', '0', '0']}
# prepare for wallpapers
path = r'{}\WallpaperEnhancer\Wallpapers'.format(os.environ['USERPROFILE'])
files = os.listdir(path)
images_str = [x.replace('.jpeg', '') for x in files]
images = [int(x) for x in images_str]
diff = [abs(x - int(get_time())) for x in images]
first = str(images[diff.index(min(diff))])
if len(first) == 5:
first = '0' + first
def __call__(self, i):
self.sysStats = updateSysStats(self.sysStats)
sysStatsX = extractSysStats(self.sysStats, 'time')
#CPU percentage
self.ax1.cla()
self.ax1.update(self.ax1props)
cpuPercent = extractSysStats(self.sysStats, 'cpuPercent')
cpuColors = ['y', 'b', 'g', 'm']
for idx, color in zip(range(4), cpuColors):
self.ax1.bar(sysStatsX,
cpuPercent[idx],
width=2,
zs=idx,
zdir='y',
color=color * len(sysStatsX),
alpha=.8)
#CPU temperature
cpuTempCel = extractSysStats(self.sysStats, 'cpuTempCel')
self.lines[1]['cpuTempCel'].set_data(sysStatsX, cpuTempCel)
#memory percertange
memPercent = extractSysStats(self.sysStats, 'memPercent')
self.lines[1]['memPercent'].set_data(sysStatsX, memPercent)
#globe
if max(self.sysStats.keys()) > self.ax4TimeToUpdate:
if max(self.sysStats.keys()) > self.ax4TimeToGeoLoc:
try:
geolocResponse = self.http.request(
'GET', 'http://ipinfo.io/json')
geolocData = json.loads(geolocResponse.data)
self.ax4GeoLoc = eval(geolocData['loc'])[0:2]
except:
self.ax4GeoLoc = self.ax4GeoLoc
self.ax4.cla()
self.ax4.set_global()
self.ax4.coastlines()
# self.ax4.stock_img()
# self.ax4.background_img(name='BM', resolution='low')
utcnow = datetime.utcnow()
self.ax4.add_feature(Nightshade(utcnow, alpha=.15))
scatterLongitudes = [x[1] for x in CitiesCoords.values()
] #+[self.ax4GeoLoc[1]]
scatterLatitudes = [x[0] for x in CitiesCoords.values()
] #+[self.ax4GeoLoc[0]]
scatterColors = ['c'] * len(CitiesCoords) #+['r']
self.ax4.scatter(scatterLongitudes,
scatterLatitudes,
s=10,
c=scatterColors,
alpha=.8,
transform=ccrs.PlateCarree())
self.ax4.gridlines(crs=ccrs.PlateCarree(),
xlocs=[self.ax4GeoLoc[1]],
ylocs=[self.ax4GeoLoc[0]],
color='y',
alpha=.4)
self.ax4.plot([self.ax4GeoLoc[1]], [self.ax4GeoLoc[0]],
ms=7,
c='r',
transform=ccrs.PlateCarree(),
**{
'marker': '$\\bigoplus$',
'linestyle': '',
'markeredgewidth': .1
})
for (k, v) in CitiesCoords.items():
self.ax4.text(v[1] + 3,
v[0] - 3,
k,
fontsize='xx-small',
color='b',
alpha=.95,
horizontalalignment='left',
verticalalignment='top',
transform=ccrs.Geodetic())
sun = Sun(self.ax4GeoLoc[0], self.ax4GeoLoc[1])
today = utcnow.date()
sunrises = [
sun.get_sunrise_time(d) for d in
[today - timedelta(days=1), today, today + timedelta(days=1)]
]
sunsets = [
sun.get_sunset_time(d) for d in
[today - timedelta(days=1), today, today + timedelta(days=1)]
]
sunTimes = sunrises + sunsets
sunTimes = [d.replace(tzinfo=None) for d in sunTimes]
sunTimes.sort()
sunTimeLast = [
t for t in sunTimes if t < utcnow.replace(tzinfo=None)
][-1]
sunTimeNext = [
t for t in sunTimes if t >= utcnow.replace(tzinfo=None)
][0]
sunHoursDeltas = [t - utcnow for t in [sunTimeLast, sunTimeNext]]
sunHours = [
td.days * 24 + td.seconds / 3600 for td in sunHoursDeltas
]
sunHHMMs = [
'{:+03.0f}:{:02.0f}'.format(math.trunc(sh),
60 * abs(sh - math.trunc(sh)))
for sh in sunHours
]
meStrTxts = [
self.ax4.text(self.ax4GeoLoc[1] + txtPosShiftHor,
self.ax4GeoLoc[0] + 3,
meStr,
fontsize='xx-small',
fontweight='normal',
color='m',
alpha=.99,
horizontalalignment=txtPosAlignHor,
transform=ccrs.Geodetic())
for (meStr, txtPosAlignHor, txtPosShiftHor
) in zip(sunHHMMs, ['right', 'left'], [-3, 3])
]
for txtObj in meStrTxts:
txtObj.set_path_effects(
[PathEffects.withStroke(linewidth=2, foreground='w')])
self.ax4TimeToUpdate += timedelta(seconds=300)
self.ax4TimeToGeoLoc += timedelta(seconds=1200)
line = f.readline()
try:
last = datetime.fromisoformat(line)
except:
print(
'The last execution date is an invalid value. Delete the `.last` file.'
)
exit(1)
if now.date() == last.date():
# Do nothing
exit(0)
try:
sun = Sun(args.latitude, args.longitude)
sunset = sun.get_sunset_time()
except:
print('Uncalculated latitude and longitude.')
exit(1)
if args.add:
try:
add_timedelta = timedelta(minutes=args.add)
except:
print('Uncalculated additional time.')
exit(1)
sunset += add_timedelta
if now < sunset:
# Do nothing
exit(0)
def get_sunlight_data(bbox,
center=DEFAULT_COORDS,
start_time='2016-09-28',
end_time='2019-09-28'):
sun = Sun(center[1], center[0])
for cc in range(0, 11, 1):
wms_true_color_request = WmsRequest(
layer='TRUE_COLOR',
bbox=bbox,
width=1000,
height=1000,
time=(start_time, end_time),
maxcc=cc / 10,
instance_id='0d1f2199-b4b9-4bad-b88b-8b2423e57b93')
data = wms_true_color_request.get_dates()
for date in data:
sunrise = sun.get_sunrise_time(date)
sunset = sun.get_sunset_time(date)
suntime = (sunset - sunrise)
suntime_hour = (sunset.hour - sunrise.hour)
suntime_minute = (sunset.minute - sunrise.minute)
sunrise_f = "%02d:%02d" % (sunrise.hour, sunrise.minute)
sunset_f = "%02d:%02d" % (sunset.hour, sunset.minute)
# print(sunrise_f)
# print(sunset_f)
suntime_number_uf = (int(suntime_hour) +
round(int(suntime_minute) / 60, 2))
suntime_number_f = '{:0>5.02f}'.format(suntime_number_uf)
#print("number: ", suntime_number_uf)
pw = ((suntime_number_uf * 0.2 * 1) +
(suntime_number_uf * 0.2 * 0.7) +
(suntime_number_uf * 0.3 * 0.4) +
(suntime_number_uf * 0.3 * 0.2)) * 1000
real_cc = cc / 10
if (real_cc < 0.31):
kwh = pw * 1
elif (real_cc >= 0.31 and real_cc < 0.71):
kwh = pw * 0.6
elif (real_cc >= 0.71 and real_cc < 0.91):
kwh = pw * 0.3
elif (real_cc >= 0.91):
kwh = pw * 0.1
sunlight_data.append([
date, sunrise_f, sunset_f,
"%d%%" % (cc * 10), suntime, suntime_number_f,
round(pw),
round(kwh)
])
# print(sunlight_data)
return remove_duplicates(sunlight_data)
#Getting the position of yesterday's date on the calender
dt = datetime.datetime.now()- datetime.timedelta(days=1)
#print(str(datetime.datetime.now()))
year = dt.year
month = dt.month
day = dt.day
hour = dt.hour
#Checking if it is day or night
latitude = 36.3504
longitude = 127.3845
sun = Sun(latitude, longitude)
sr_time = (sun.get_sunrise_time()+datetime.timedelta(hours=9)).time()
ss_time = (sun.get_sunset_time()+datetime.timedelta(hours=9)).time()
sr_hour = int(sr_time.hour)
ss_hour = int(ss_time.hour)
curr_time = datetime.datetime.now().time()
isDay = 0
if (sr_time < curr_time < ss_time):
isDay = 1
#retrieving data
dict_param = {
'yy': year,
'mm': month,
'dd': day,
'hh': hour,
'obs': 0
}
def sun_time(self):
sun_time = Sun(self.latlon_point.latitude, self.latlon_point.longitude)
self.date = self.date + timedelta(days=self.date_increase)
try:
today_sunrise = sun_time.get_sunrise_time(self.date)
except SunTimeException:
if date(year=self.date.year, month=3, day=21)\
< self.date.date()\
< date(year=self.date.year, month=9, day=22):
return 0, 360
return 0, 0
try:
today_sunset = sun_time.get_sunset_time(self.date)
except SunTimeException:
if date(year=self.date.year, month=3, day=21)\
< self.date.date()\
< date(year=self.date.year, month=9, day=22):
return 0, 360
return 0, 0
# This is *super* ugly, I'm sure we can find a more elegant way to do this
now = datetime.utcnow() - timedelta(hours=0)
today_sunrise = today_sunrise.replace(tzinfo=None)
today_sunset = today_sunset.replace(tzinfo=None)
# After Sunrise, after Sunset
if now > today_sunrise and today_sunset:
# Get timedelta for each
today_sunrise = now - today_sunrise
today_sunset = now - today_sunset
# Convert timedelta into minutes and round
today_sunrise = round(today_sunrise.seconds / 60)
today_sunset = round(today_sunset.seconds / 60)
# Convert minutes into angles
today_sunrise = today_sunrise * 0.25
today_sunset = today_sunset * 0.25
# Before Sunrise, after Sunset
elif now < today_sunrise and today_sunset:
today_sunrise = today_sunrise - now
today_sunset = today_sunset - now
today_sunrise = round(today_sunrise.seconds / 60)
today_sunset = round(today_sunset.seconds / 60)
today_sunrise = 360 - (today_sunrise * 0.25)
today_sunset = 360 - (today_sunset * 0.25)
# After Sunrise, before Sunset
else:
today_sunrise = now - today_sunrise
today_sunset = today_sunset - now
today_sunrise = round(today_sunrise.seconds / 60)
today_sunset = round(today_sunset.seconds / 60)
today_sunrise = today_sunrise * 0.25
today_sunset = 360 - (today_sunset * 0.25)
return today_sunrise, today_sunset
ind_array = np.concatenate((ind_array, [len(np_cast) - 1]), axis=0)
# calculating the sunrise and sunset times for each cast (if possible)
# If the lattitudes are in the far north or south during summer/winter
# There are no sunrise or sunset as it will all be day or night
# All the times are in UTC
k = 0
for j in range(len(ind_array) - 1):
d = date(np_year[ind_array[j]], np_month[ind_array[j]],
np_day[ind_array[j]])
sun = Sun(np_lat[ind_array[j]], np_long[ind_array[j]])
try:
sr = sun.get_sunrise_time(d)
ss = sun.get_sunset_time(d)
except:
# Any operation here is needed for the try method
k += 1
else:
# IF the sunrise can be calculated, then we use the suntime module
# to compute the sunrise and sunset times for each cast
sr = sun.get_sunrise_time(d)
ss = sun.get_sunset_time(d)
np_sr[ind_array[j]:ind_array[j + 1]] = round(
sr.hour + sr.minute / 60, 2)
np_ss[ind_array[j]:ind_array[j + 1]] = round(
ss.hour + ss.minute / 60, 2)
j_arr[j] = (ind_array[j], ind_array[j + 1])
import datetime
from suntime import Sun, SunTimeException
from datetime import datetime
from dateutil import tz
# Auto-detect timezones
from_zone = tz.tzutc()
to_zone = tz.tzlocal()
# Felton, CA 37.0513° N, 122.0733° W
city_name = "Felton, CA"
latitude = 37.0513
longitude = -122.0733
sun = Sun(latitude, longitude)
# Get today's sunrise and sunset in UTC
today_sr_utc = sun.get_sunrise_time()
today_sr_local = sun.get_local_sunrise_time()
today_ss_utc = sun.get_sunset_time()
today_ss_local = sun.get_local_sunset_time()
print('Today at {} the sun rose at {} and goes down at {} UTC'.format(
city_name, today_sr_utc.strftime('%H:%M'), today_ss_utc.strftime('%H:%M')))
print('Today at {} the sun rose at {} and goes down at {} localtime'.format(
city_name, today_sr_local.strftime('%H:%M'),
today_ss_local.strftime('%H:%M')))
