def compute(self): location = Location(('name', 'reg', self.lat, self.lon, 'Europe/Moscow', self.alt)) # 15' sun bottom + 35' refraction alt = location.solar_elevation() daytime = 'day' daytime_ext = 'day' if -6 <= alt < -5. / 6: daytime = 'twilight' daytime_ext = 'civil_twilight' elif -12 <= alt < -6: daytime = 'night' daytime_ext = 'nautical_twilight' elif -18 <= alt < -12: daytime = 'night' daytime_ext = 'astro_twilight' elif alt < -18: daytime = 'night' daytime_ext = 'night' self.context.set_item_value('daytime', daytime) self.context.set_item_value('daytime_ext', daytime_ext) self.context.set_item_value('sun_alt', alt) self.context.set_item_value('sun_az', location.solar_azimuth()) sun = location.sun() self.context.set_item_value('sunrise', sun['sunrise']) self.context.set_item_value('sunset', sun['sunset']) self.context.set_item_value('noon', sun['noon']) self.context.set_item_value('moon_phase', location.moon_phase())
def getSunTimes(self): a = Location() a.timezone = "Europe/Berlin" tz = pytz.timezone(a.timezone) sunData = a.sun() n = datetime.datetime.now() n = tz.localize(n)
#!/usr/bin/env python import datetime from astral import Astral, Location import pytz def dt2min(dt): return dt.hour * 60 + dt.minute loc = Location(("Santa Clara", "California", 37.21, -121.58, "US/Pacific", 22)) loc.solar_depression = 'civil' oneday = datetime.timedelta(days=1) soy = datetime.date(2016, 1, 1) for i in (range(1, 366)): sun = loc.sun(date=soy, local=True) print("{{ 0x{0:X}, 0x{1:X} }},".format(dt2min(sun['sunrise']), dt2min(sun['sunset']))) soy = soy + oneday
class AstralPositions: def __init__(self, lat, lon, panel_tilt=20, session_id=None, ip_or_url='192.168.15.7', port=27017): # Date/wall time attributes if session_id == None: import uuid self.session_id = uuid.uuid1() self.a = Astral() self.timezone_string = 'US/Pacific' # Timezone from lat/lng tzfinder = timezonefinder.TimezoneFinder() self.tz = tzfinder.certain_timezone_at(lat=lat, lng=lon) self.location = Location(('Burlingame', 'Pacific West', lat, lon, self.timezone_string, 6.1)) self.sun = self.location.sun(date=dt.datetime.today().date(), local=True) print(self.sun) # MongoDB Tracking self.mongo_client = MongoClient(ip_or_url, port) self.db = self.mongo_client.astral # Tilt of theoretical panel self.tilt = math.radians(panel_tilt) def get_now_local(self): now = dt.datetime.now() localtime = pytz.timezone(self.tz) now_local = localtime.localize(now) return now_local @staticmethod def perdelta(start, end, delta): curr = start while curr <= end: yield curr curr += delta def get_azimuth(self, dt_local=None): if dt_local == None: dt_local = self.get_now_local() angle = self.location.solar_azimuth(dt_local) return angle def get_altitude(self, dt_local=None): if dt_local == None: dt_local = self.get_now_local() angle = self.location.solar_elevation(dt_local) return angle def _angular_doc(self): datetime = self.get_now_local() alt = self.get_curr_altitude(datetime) az = self.get_curr_azimuth(datetime) doc = { "altitude": alt, "azimuth": az, "datetime": datetime, "sessionid": self.session_id } solar_angles = self.db.solar_angles _id = solar_angles.insert_one(doc).inserted_id def collect_angular_data(period=2): pass def get_azimuth_angles(self, start, end, frequency=60, continuous=True): td = dt.timedelta(seconds=frequency) # datetimes = [start + i*td for i in ] # delta = end-start datetimes = list(self.perdelta(start, end, td)) angles = [self.get_azimuth(d) for d in datetimes] angles = pd.DataFrame({ 'Datetime Local': datetimes, 'Angle (deg)': angles }) # while datetime <= end: # start if not continuous: pass return angles def get_altitude_angles(self, start, end, frequency=60, continuous=True): td = dt.timedelta(seconds=frequency) # datetimes = [start + i*td for i in ] datetimes = list(self.perdelta(start, end, td)) angles = [self.get_altitude(d) for d in datetimes] angles = pd.DataFrame({ 'Datetime Local': datetimes, 'Angle (deg)': angles }) # while datetime <= end: # start if not continuous: pass return angles def get_solar_angles(self, start, end): local_start = self.tz.localize(start) local_end = self.tz.localize(end) azimuth_df = self.get_azimuth_angles(start=local_start, end=local_end) altitude_df = self.get_altitude_angles(start=local_start, end=local_end) altitude_angles = altitude_df['Angle (deg)'] azimuth_angles = azimuth_df['Angle (deg)'] zenith_angles = altitude_angles.apply(lambda x: 90 - x) datetimes = altitude_df['Datetime Local'] azimuth_angles_rad = azimuth_angles.map(math.radians) zenith_angles_rad = zenith_angles.map(math.radians) altitude_angles_rad = altitude_angles.map(math.radians) cos_correct_df = ap.get_cos_factors(azimuth_angles_rad, zenith_angles_rad) solar_angles_df = pd.DataFrame({ 'Azimuth (rad)': azimuth_angles_rad, 'Altitude (rad)': altitude_angles_rad, 'Datetime Local': datetimes }) return solar_angles_df
def textual_information(data_parsed, geo_data, config): """ Add textual information about current weather and astronomical conditions """ def _shorten_full_location(full_location, city_only=False): def _count_runes(string): return len(string.encode('utf-16-le')) // 2 words = full_location.split(",") output = words[0] if city_only: return output for word in words[1:]: if _count_runes(output + "," + word) > 50: return output output += "," + word return output city = Location() city.latitude = geo_data["latitude"] city.longitude = geo_data["longitude"] city.timezone = geo_data["timezone"] output = [] timezone = city.timezone datetime_day_start = datetime.datetime.now()\ .replace(hour=0, minute=0, second=0, microsecond=0) sun = city.sun(date=datetime_day_start, local=True) format_line = "%c %C, %t, %h, %w, %P" current_condition = data_parsed['data']['current_condition'][0] query = {} weather_line = wttr_line.render_line(format_line, current_condition, query) output.append('Weather: %s' % weather_line) output.append('Timezone: %s' % timezone) tmp_output = [] tmp_output.append(' Now: %%{{NOW(%s)}}' % timezone) tmp_output.append('Dawn: %s' % str(sun['dawn'].strftime("%H:%M:%S"))) tmp_output.append('Sunrise: %s' % str(sun['sunrise'].strftime("%H:%M:%S"))) tmp_output.append(' Zenith: %s' % str(sun['noon'].strftime("%H:%M:%S "))) tmp_output.append('Sunset: %s' % str(sun['sunset'].strftime("%H:%M:%S"))) tmp_output.append('Dusk: %s' % str(sun['dusk'].strftime("%H:%M:%S"))) tmp_output = [ re.sub("^([A-Za-z]*:)", lambda m: colorize(m.group(1), "2"), x) for x in tmp_output] output.append( "%20s" % tmp_output[0] \ + " | %20s " % tmp_output[1] \ + " | %20s" % tmp_output[2]) output.append( "%20s" % tmp_output[3] \ + " | %20s " % tmp_output[4] \ + " | %20s" % tmp_output[5]) city_only = False suffix = "" if "Simferopol" in timezone: city_only = True suffix = ", Крым" if config["full_address"]: output.append('Location: %s%s [%5.4f,%5.4f]' \ % ( _shorten_full_location(config["full_address"], city_only=city_only), suffix, geo_data["latitude"], geo_data["longitude"], )) output = [ re.sub("^( *[A-Za-z]*:)", lambda m: colorize(m.group(1), "2"), re.sub("^( +[A-Za-z]*:)", lambda m: colorize(m.group(1), "2"), re.sub(r"(\|)", lambda m: colorize(m.group(1), "2"), x))) for x in output] return "".join("%s\n" % x for x in output)
#camera.awb_mode = 'off' camera.iso = 800 # ser = serial.Serial("/dev/ttyACM0",9600) camera.exposure_mode = 'off' l = Location() l.name = 'current' l.region = 'region' l.latitude = cfg['latitude'] l.longitude = cfg['longitude'] l.timezone = 'America/Chicago' l.elevation = cfg['elevation'] l.sun() record_count = 0 #### 1. Function definitions ######################################### #### _) Networking def make_request(url, req_type, data): r = "" if req_type == "post": r = requests.post(url, json=data, headers={"x-api-key": api_key, "content-type": "application/json"}) elif req_type == "get": r = requests.get(url, json=data, headers={"x-api-key": api_key, "content-type": "application/json"}) print(r)
def do_PUT(self): logging.debug("-- PUT") length = int(self.headers["Content-Length"]) path = self.translate_path(self.path) data_string = self.rfile.read(length) print(data_string) if "/toggle" in self.path: logging.debug("--- TOGGLE") self.send_response(200, "TOGGLE_OK") self.send_header("Content-type", "text/html") self.end_headers() if HTTPHandler.br > 0: HTTPHandler.br = 0 self.disable_pwm() # disable wakeup if we are right in one... if self.isInWakeupsequence == True: if HTTPHandler.wakeup_task is not None: HTTPHandler.wakeup_task.cancel() self.isInWakeupsequence = False else: HTTPHandler.br = 255 self.enable_pwm() logging.debug(HTTPHandler.br) GPIO.set_PWM_dutycycle(PWM, HTTPHandler.br) if "/on" in self.path: logging.debug("DEPRECATED --- ON") self.send_response(200, "ON_OK") self.send_response(200, "OFF_OK") self.send_header("Content-type", "text/html") self.end_headers() HTTPHandler.br = 255 logging.debug(HTTPHandler.br) self.enable_pwm() GPIO.set_PWM_dutycycle(PWM, HTTPHandler.br) if "/off" in path: logging.debug("DEPRECATED --- OFF") self.send_response(200, "OFF_OK") self.send_header("Content-type", "text/html") self.end_headers() self.wfile.write("") HTTPHandler.br = 0 self.disable_pwm() GPIO.set_PWM_dutycycle(PWM, HTTPHandler.br) if "/incr" in path: logging.debug("--- INCR") self.send_response(200, "INCR_OK") self.send_header("Content-type", "text/html") self.end_headers() self.wfile.write("") HTTPHandler.br = min(HTTPHandler.br + 10, 255) GPIO.set_PWM_dutycycle(PWM, int(HTTPHandler.br)) # if HTTPHandler.br > 5 and not self.pwm_is_enabled: # self.enable_pwm() if "/decr" in path: logging.debug("--- DECR") self.send_response(200, "INCR_OK") self.send_header("Content-type", "text/html") self.end_headers() self.wfile.write("") HTTPHandler.br = max(HTTPHandler.br - 10, 0) logging.debug(HTTPHandler.br) GPIO.set_PWM_dutycycle(PWM, int(HTTPHandler.br)) if HTTPHandler.br < 0: self.disable_pwm() if "/wakeuptime" in path: logging.debug("--- New wakeup time: ") #parse json data = simplejson.loads(data_string) wakeup_time = data['time'] wakeup_time = int(wakeup_time) #wakeup_time = parser.parse(wakeup_time print(datetime.now(utc)) print(int(wakeup_time)) now = int(time.time() * 1000) #dt = datetime.today() # Get timezone naive now #now = int(dt.timestamp()) #now = (datetime.now()) #-datetime.fromtimestamp(0)).total_seconds() #datetime(1970,1,1)).total_seconds() print(int(now)) logging.info("--- sheduling wakeup in ") t = int((wakeup_time - now) / 1000) print(t) logging.info(int(wakeup_time)) logging.debug("killing old wakeups") if HTTPHandler.wakeup_task is not None: HTTPHandler.wakeup_task.cancel() HTTPHandler.wakeup_task = Timer( t - (LIGHT_START_BEFORE_ALARM_TIME * 60), self.startIncrLight) HTTPHandler.wakeup_task.start() self.send_response(200, 'WAKEUP_OK') self.send_header("Content-type", "text/html") self.end_headers() returntime = (str(int(wakeup_time))) print("returntime: ") print(returntime) self.wfile.write(returntime) if "/sunrise" in path: logging.debug("--- Wakeup set to Sunrise ---") self.send_response(200, 'SUNRISE_OK') self.send_header("Content-type", "text/html") self.end_headers() send_url = 'http://freegeoip.net/json' r = requests.get(send_url) j = json.loads(r.text) lat = j['latitude'] lon = j['longitude'] a = Astral() a.solar_depression = 'civil' l = Location() l.name = 'name' l.region = 'region' l.latitude = lat l.longitude = lon l.timezone = j['time_zone'] #TODO: l.elevation = 200 l.sun() tomorrow = datetime.today() + timedelta(days=1) sun = l.sun(date=tomorrow, local=True) local_tz = pytz.timezone(j['time_zone']) wakeup_time = sun['sunrise'] now = datetime.now(utc) t = wakeup_time - now logging.info("Wakeup at") logging.info(wakeup_time) logging.debug("killing old wakeups") if HTTPHandler.wakeup_task is not None: HTTPHandler.wakeup_task.cancel() HTTPHandler.wakeup_task = Timer( t.total_seconds() - (LIGHT_START_BEFORE_ALARM_TIME * 60), self.startIncrLight) HTTPHandler.wakeup_task.start() self.wfile.write("%f" % wakeup_time)
def test_Location_Sun(): c = Location() c.sun()
class Runner(object): def __init__(self, target_ip, bulb, delta, tz, lat, long, location_name='Location', region_name='Russia', elevation=0, color=((255, 255, 255), (225, 143, 0)), brightness=(17, 50)): # ip address of target PC self.target_ip = target_ip # bulb attached to this pc self.bulb = bulb # check the current state self.__turned_on__ = self.turned_on # sunset offset percentage between dusk and sunset, when bulb is turn on self.delta = delta # color and brightness gradient for sunrise effect self.grad = [ (int(c.red * 255), int(c.green * 255), int(c.blue * 255)) for c in list( Color(rgb=(color[0][0] / 255, color[0][1] / 255, color[0][2] / 255)).range_to( Color(rgb=(color[1][0] / 255, color[1][1] / 255, color[1][2] / 255)), 30)) ] self.brightness = range(*brightness) if brightness[1] > brightness[0] else \ list(reversed(range(*list(reversed(brightness))))) # setup current location and timezone self.tz = pytz.timezone(tz) self.location = Location( (location_name, region_name, lat, long, tz, elevation)) self.dusk = None self.sunrise = None self.sunset = None self.set_sun() # logging self.logger = logging.getLogger('yee') formatter = logging.Formatter('%(asctime)-15s %(message)s') fh = logging.FileHandler('yee.log') ch = logging.StreamHandler() ch.setFormatter(formatter) fh.setFormatter(formatter) self.logger.setLevel(logging.INFO) self.logger.addHandler(fh) self.logger.addHandler(ch) self.logger.info('START with current state: %s', 'on' if self.__turned_on__ else 'off') def toggle(self, state=None, retry=3): """ toggle bulb power state :param state: :param retry: :return: """ try: bulb = Bulb(self.bulb) if state is False: self.upd(0) bulb.turn_off() self.__turned_on__ = False elif state is True: bulb.turn_on() self.__turned_on__ = True else: bulb.toggle() self.__turned_on__ = not self.__turned_on__ except BulbException: time.sleep(10) if retry > 0: return self.toggle(state, retry - 1) def upd(self, progress=None, retry=3): """ update the current bulb colour and brightness :param progress: :param retry: :return: """ try: _progress = progress or min( max((self.now - self.sunset).seconds, 0) / (self.dusk - self.sunset).seconds, 1) bulb = Bulb(self.bulb) bulb.set_rgb(*self.grad[min(int(_progress * len(self.grad)), len(self.grad) - 1)]) bulb.set_brightness(self.brightness[min( int(_progress * len(self.brightness)), len(self.grad) - 1)]) except BulbException: time.sleep(10) if retry > 0: return self.upd(progress, retry - 1) def get_state(self, retry=3): """ get the current bulb state :return: """ try: return Bulb(self.bulb).get_properties()['power'] except BulbException: time.sleep(10) return self.get_state(retry - 1) if retry > 0 else None @property def turned_on(self): """ check the current bulb power state :return: boolean """ state = self.get_state() return self.__turned_on__ if (state is None) else state == 'on' @property def is_up(self): ret = subprocess.call(['ping', '-c', '5', '-W', '3', self.target_ip], stdout=open('/dev/null', 'w'), stderr=open('/dev/null', 'w')) return ret == 0 @property def now(self): return self.tz.fromutc(datetime.utcnow()) def check(self): now = self.now # sun is up - wait until next day if not self.sunset < now < self.sunrise: # turn off if it still up if self.turned_on: self.logger.info('turned OFF: %s', 'sunrise') self.toggle(False) # sleep until next sunset self.set_sun() delay = (self.sunset - now).seconds self.logger.info('sleep for : %s', delay) time.sleep(delay) return self.check() # pc is powered off - shut down bulb # check every minute if not self.is_up: if self.turned_on: self.logger.info('turned OFF: %s', 'pc is down') self.toggle(False) time.sleep(60) return self.check() # sun is down # pc is up # bulb should turned on # check every minute if not self.turned_on: self.logger.info('turned ON: %s', 'default state') self.toggle(True) # try to set colour AFTER turn the bulb on if self.sunset < now < self.dusk: self.upd() time.sleep(60) return self.check() def set_sun(self): """ update data :return: """ now = self.now i1, i2 = self.location.sun(now), self.location.sun(now + timedelta(1)) self.dusk = i1['dusk'] self.sunset = i1['sunset'] + timedelta( seconds=int((self.dusk - i1['sunset']).seconds * self.delta)) self.sunrise = i2['sunrise'] def run(self): self.check()
def _update_sun_info(self): location = Location(('name', 'region', float(self._latitude), float(self._longitude), 'GMT+0', 0)) self.sun = location.sun()
time.sleep(2) pwm_watering.stop() log_w('OK ', str(GPIO.input(17))) return date_today else: log_w('NT ', str(GPIO.input(17))) return last_watering #main indication(3) while not flag_off: if date.today() != date_today: date_today = date.today() sun = astr.sun(date=datetime.date.today(), local=True) sunrise = str(sun['sunrise'])[11:16] sunrise = int(sunrise.replace(':', '')) sunset = str(sun['sunset'])[11:16] sunset = int(sunset.replace(':', '')) log_m('Sunrise = ' + str(sunrise) + ' sunset = ' + str(sunset)) c_time = str(datetime.datetime.now())[11:16] c_time = int(c_time.replace(':', '')) flag_heating = heating() #heating flag_lighting = lighting() #lighting last_fertilizers = fertilizers() #fertilizers last_watering = watering() #watering
l.name = os.getenv('CITY', 'Trondheim') l.region = os.getenv('REGION', 'Europe') # But these are important l.latitude = float(os.getenv('LATITUDE', '63.446827')) l.longitude = float(os.getenv('LONGITUDE', '10.421906')) l.timezone = os.getenv('TIMEZONE', 'Europe/Oslo') l.elevation = float(os.getenv('ELEVATION', '0')) daytime = -1 changed = False while True: now = datetime.datetime.now() if now.hour < l.sun()['dawn'].hour and time != 3: # Night daytime = 3 changed = True elif now.hour < l.sun()['noon'].hour and time != 0: # Morning daytime = 0 changed = True elif now.hour < l.sun()['sunset'].hour and time != 1: # Lunch daytime = 1 changed = True elif now.hour < l.sun()['dusk'].hour and time != 2:
import datetime, sys from astral import Astral, Location from datetime import date lat = float(sys.argv[1]) lon = float(sys.argv[2]) zone = sys.argv[3] l = Location(('wsprep', 'local', lat, lon, zone, 0)) l.sun() d = date.today() sun = l.sun(local=True, date=d) print(str(sun['sunrise'])[11:16] + " " + str(sun['sunset'])[11:16])
l.name = os.getenv('CITY', 'Trondheim') l.region = os.getenv('REGION', 'Europe') # But these are important l.latitude = float(os.getenv('LATITUDE', '63.446827')) l.longitude = float(os.getenv('LONGITUDE', '10.421906')) l.timezone = os.getenv('TIMEZONE', 'Europe/Oslo') l.elevation = float(os.getenv('ELEVATION', '0')) daytime = -1 changed = False while True: now = datetime.datetime.now() if now.hour < l.sun()['dawn'].hour and time != 3: # Night daytime = 3 changed = True elif now.hour < l.sun()['noon'].hour and time != 0: # Morning daytime = 0 changed = True elif now.hour < l.sun()['sunset'].hour and time != 1: # Lunch daytime = 1 changed = True elif now.hour < l.sun()['dusk'].hour and time != 2: