I would like to emphasize again that the Raspberry Pi does not have an RTC (Real Time Clock). In order for the Raspberry Pi to set the correct time at startup, it must be online. Of course, you can set the clock manually or you can solder an RTC. The difference is that the Pi only needs to be online for a short time. Another advantage is that the Python script is much shorter and therefore clearer.

Since Astral works with Python 3, you are not limited to a Raspberry Pi. But the Pi is well suited for smart home projects or just to experiment with it.

Install Astral

On the Raspberry Pi, Astral is quickly installed via pip, provided that this is available. If not – install it. Here are the commands for both:

sudo apt install python3-pip
pip3 install astral

That’s it. Unlike in the desktop version, gpiozero is not installed on Raspbian Lite. Since I switch the GPIO pins with Astral at the end, I do this step right away:

sudo apt install python3-gpiozero

Now I am good to go. By the way, my Raspberry Pi is running Raspbian Buster.

My new script

I would like to show you the script I am using now – at least with the concept of it. It looks lie this:

from astral import LocationInfo
from astral.sun import sun
from datetime import datetime
from time import sleep
import pytz

utc=pytz.UTC

city = LocationInfo("London", "England", "Europe/London", 51.5, -0.116) # swap with your location

while True:

    s = sun(city.observer)
    time_now = utc.localize(datetime.now())
    sunrise = s["sunrise"]
    dusk = s["dusk"]

    if time_now > sunrise and time_now < dusk: # am I in between sunset and dusk?
        print("Daylight")
    else:
        print("Switch on light")

    sleep(60)

The script is very logical. In my case, it gets the data for sunrise and dusk. Then the program checks if the current time is between sunrise and dusk. If that is the case, it tells you that it is daylight — if not, it is dark.

This is an infinite loop that pauses for 60 seconds at the end of a run.

With my online solution I still checked the date and only made a query to the API when the date changed. I could do the same here, but the calculation is so fast that I don’t think it’s necessary.

My night light with pfFace Digital and Astral

Why I use a piFace Digital? Because I already have it and it was a birthday present — plus the thing works. Today I would rather use an Automation HAT, I think — or take a relay and switch it via GPIO.

My Raspberry Pi B with the piFace Digital now switches my night light as follows.

from astral import LocationInfo
from astral.sun import sun
from datetime import datetime
from time import sleep
import pifacedigitalio as p
import pytz

utc=pytz.UTC

pifacedigital = p.PiFaceDigital()
pifacedigital.output_pins[3].turn_on() # Schaltet bei einem Pi-Neustart an, ist nur ein Check

sleep(10)

city = LocationInfo("London", "England", "Europe/London", 51.5, -0.116) # swap with your location

while True:

    s = sun(city.observer)
    time_now = utc.localize(datetime.now())
    sunrise = s["sunrise"]
    dusk = s["dusk"]

    if time_now > sunrise and time_now < dusk: # am I in between sunrise and dusk?
        if pifacedigital.output_pins[3].value == 1: # if the relay is not off
            pifacedigital.output_pins[3].turn_off() # switch it off
    else:
        if pifacedigital.output_pins[3].value != 1: # if the relay is not on
            pifacedigital.output_pins[3].turn_on() # switch it on

    sleep(60)

In the if-else, the system checks whether the light is already switched on or not. With this I prevent a short flickering because otherwise the piFace Digital will switch the light.

I also convert time_now to UTC because otherwise I cannot compare. The date including time from Astral comes with a time zone specification and if I do not convert time_now, the program tells me: TypeError: can’t compare offset-naive and offset-aware datetimes

This is basically: you cannot compare apples with oranges.

My Pi is running in the timezone UTC, just to make things easier. If you want to work with a time zone, you could for example use timedelta to adjust your current time by x hours to match your timezone. There are several possibilities at this point. Here an example with plus and minus 2 hours.

import datetime

tdplus = datetime.datetime.now() + datetime.timedelta(hours=2)
tdminus = datetime.datetime.now() - datetime.timedelta(hours=2)

print(tdplus)
print(tdminus)

Switching GPIO Pins with Astral

The script can of course also be easily customized to switch GPIO pins. As said before, you can switch a suitable relay with it or you just experiment with an LED.

from astral import LocationInfo
from astral.sun import sun
from datetime import datetime
from time import sleep
from gpiozero import LED
import pytz

utc=pytz.UTC

led = LED(17)

city = LocationInfo("London", "England", "Europe/London", 51.5, -0.116) # swap with your location


while True:

    s = sun(city.observer)
    time_now = utc.localize(datetime.now())
    sunrise = s["sunrise"]
    dusk = s["dusk"]

    if time_now > sunrise and time_now < dusk: # am I in between sunrise and dusk?
        led.off()
    else:
        led.on()

    sleep(60)

In my case, I switch GPIO17 (pin 11).

Maybe I will change the behaviour to the end of the dawn. The advantage of this solution compared to a conventional timer is that I can really only switch the night light during the dark hours. Another advantage is that it is simply fun to fiddle with.

Astral can do a lot more

While we are working with Astral let’s have a look at a few practical examples.

In the documentation you can read that location data for various cities are available in a database. All capitals are included, plus a few additional cities from Great Britain and the USA. You can query the database as follows:

from astral import LocationInfo
from astral.geocoder import database, lookup

city = lookup("Amsterdam", database())
print(city)

This gives me the following output:

I can also query the values individually:

from astral import LocationInfo
from astral.geocoder import database, lookup

city = lookup("Berlin", database())

print(city.name)
print(city.region)
print(city.timezone)
print(city.latitude)
print(city.longitude)

But I don’t have to use the database, I can define my location. Of course, I don’t have to import astral.geocoder for this. If you want the calculation to be as exact as possible, it is best to define latitude and longitude yourself:

from astral import LocationInfo

city = LocationInfo(name="Cordoba", region="Spain", timezone="Europe/Spain", latitude=37.8833333, longitude=-4.7666667)

print((
    f"Information for {city.name}/{city.region}\n"
    f"Timezone: {city.timezone}\n"
    f"Latitude: {city.latitude:.02f}; Longitude: {city.longitude:.02f}\n" ))

OK, now we’ve defined our location. Let’s see what we can do with it.

Sunrise, sunset, dawn and dusk

With the location, Astral calculates the desired times, by default in UTC. This is relatively simple and looks like this:

from astral import LocationInfo
from astral.sun import sun

city = LocationInfo(name="Cordoba", region="Spain", timezone="Europe/Spain", latitude=37.8833333, longitude=-4.7666667)

c_data = sun(city.observer)

print("Sunrise: " + str(c_data["sunrise"]))
print("Sunset: " + str(c_data["sunset"]))
print("Dawn: " + str(c_data["dawn"]))
print("Dusk: " + str(c_data["dusk"]))

It looks like that:

Note: The times are calculated when the sun breaks through the horizon in clear visibility — obstacles in the eye of the observer are ignored.

If you do not enter a date, Astral will calculate with the current date. You can also have the values calculated for a specific date. You only have to specify it when defining c_data and import datetime. Here is an example for October 21, 2019:

from astral import LocationInfo
from astral.sun import sun

city = LocationInfo(name="Cordoba", region="Spain", timezone="Europe/Spain", latitude=37.8833333, longitude=-4.7666667)

c_data = sun(city.observer, date=datetime.date(2019, 10, 21))

print("Sunrise: " + str(c_data["sunrise"]))
print("Sunset: " + str(c_data["sunset"]))
print("Dawn: " + str(c_data["dawn"]))
print("Dusk: " + str(c_data["dusk"]))

The documentation says that you can also display information about the golden hour and blue hour. Especially for photographers this is important information.

Golden hour and blue hour

The blue hour and the golden hour appear twice a day. In simple terms: blue hour > the sun is below the horizon and golden hour > just above. In the blue hour the blue light spectrum dominates and in the golden hour the colours are much softer and warmer.

Unlike sunrise or sunset, blue hour and golden hour have two values: beginning and end. If you do not give an additional value, Astral calculates to the rising sun by default. Let’s get the data:

from astral import LocationInfo
from astral.sun import golden_hour
from astral.sun import blue_hour

city = LocationInfo(name="Cordoba", region="Spain", timezone="Europe/Spain", latitude=37.8833333, longitude=-4.7666667)

gh = golden_hour(city.observer)
bh = blue_hour(city.observer)

print("Golden hour start: " + str(gh[0]))
print("Golden hour end: " + str(gh[1]))
print("Blue hour start: " + str(bh[0]))
print("Blue hour end: " + str(bh[1]))

If I want to calculate the golden hour and the blue hour for the evening, I have to set the direction of the sun to SETTING. RISING is also available, but that is the default, as already mentioned. If I want to get the data for the evening this, the code looks like this (golden hour in the evening and blue hour in the morning):

from astral import LocationInfo
from astral.sun import SunDirection
from astral.sun import golden_hour
from astral.sun import blue_hour
from datetime import datetime

city = LocationInfo(name="Cordoba", region="Spain", timezone="Europe/Spain", latitude=37.8833333, longitude=-4.7666667)

gh = golden_hour(city.observer, datetime.now().date(), SunDirection.SETTING)
bh = blue_hour(city.observer)

print("Golden hour start: " + str(gh[0]))
print("Golden hour end: " + str(gh[1]))
print("Blue hour start: " + str(bh[0]))
print("Blue hour end: " + str(bh[1]))

You can also see that the golden hour and the blue hour are not really 60 minutes. It depends a lot on location and season. So, it’s good to know when to have your camera ready.

By the way, we can also use Astral to get information about the moon.

Calculate moon phases with Astral

The tool can also output the moon phases. Using the date, the Python program spits out a number between 0 and 28. In the documentation we find how to interpret the numbers of the moon phases:

• 0 – 6.99 — new moon
• 7 – 7.99 — waxing moon
• 14 – 20.99 — full moon
• 21 – 27.99 — waning moon

To make things a bit more exciting, let’s have the moon phase of yesterday, today and tomorrow displayed. Especially the following day makes sense, if you want to know when the moon is at its fullest, for example:

from astral.moon import phase
import datetime

moon_today = phase()
moon_yesterday = phase(datetime.datetime.now() - datetime.timedelta(days=1))
moon_tomorrow = phase(datetime.datetime.now() + datetime.timedelta(days=1))

print("Mond gestern", end=": ")
print(moon_yesterday)
print("Mond heute", end=": ")
print(moon_today)
print("Mond morgen", end=": ")
print(moon_tomorrow)

If you are into star photography you want to have as little moon as possible, right? With the following script we find out, for example, when the moon is the fullest and least visible in the next 365 days:

from astral.moon import phase
import datetime

moon_dic = {}

for var in list(range(365)):
    date_temp = datetime.datetime.now().date() + datetime.timedelta(days=(var))
    moon_phase = phase(date_temp)
    moon_dic[moon_phase] = date_temp

darkest = min(moon_dic)
print(moon_dic.get(darkest), end=": ")
print(darkest)

darkest2 = max(moon_dic)
print(moon_dic.get(darkest2), end=": ")
print(darkest2)

Now I know that during the next 365 days the moon will be very little visible on September 17, 2020 and May 11, 2021.

When it’s at its fullest, I can’t say exactly. The tool tells me that between 14 – 20.99 is full moon — but not exactly when the moon is fullest. Is that exactly halfway, so 14? I’ll stare at the sky and try to find that out for myself at the next full moon.

The tool can calculate some other data. At the moment that is all I need. I can get what I want and have the data sent to my smartphone (with pushover like my Coronavirus data).

Now I have my Bitcoin Ticker, a Coronavirus Ticker and a tool for sunrise, sunset, blue hour, golden hour and moon phases. I know that there are different apps for this, but I need to install less stuff on my smartphone and I can also customize the tools the way I want to. This way I can have very specific information sent to me.

I hope that was clear

I wrote this article to understand Astral a little better myself. A few things are not obvious to me yet, but on the whole I understand how to use Astral.

Maybe this article will help you to do something useful with the tool. Now that I understand how to use it, I really like it. In any case, there are many possibilities how to use the data calculated by Astral.

The post Astral — calculate sunrise, sunset, moon phases, golden / blue hour with Python appeared first on VPN Expert.

Of course, it doesn’t matter what you switch with it. If the GPIO interface of the Raspberry Pi is sufficient, you can also switch an LED when it gets dark. This might even be enough for a night light, I have to test it. Since I have a PiFace Digital that gives me switchable 5V on the Raspberry Pi, I took this. With the GPIO interface you can also switch another relay. Other options would be you use IR or even switch the USB ports of the Raspberry Pi on and off.

Note: I switched to Astral doing this. Here is an in depth explanation how to do this and what Astral can do for you.

Sunrise off / Sunset on

Three things were important to me for this project:

1. Getting the time of sunrise and sunset of the given day.
2. Check if I am between sunrise and sunset because the relay should be off then.
3. Get the data again at the change of day. It is not necessary to retrieve the data continuously.

Where do I get the data for sunrise / sunset?

Of course, we need the data for sunrise and sunset — otherwise the project is nonsense. I get the data via sunrise-sunset.org. For the city of London, for example, the relevant URL request looks like this:

https://api.sunrise-sunset.org/json?lat=51.517576&lng=-0.07978&formatted=0

You must specify latitude (lat) and longitude (lng). The request above will give you these data:

You get the following information:

• Sunrise
• Sunset
• Solar Noon
• Day length (in seconds)
• Civil twilight — reading outside is still possible without problems
• Nautical twilight
• Astronomical twilight

It is important that all times are given in UTC. The time zone is not considered, but I don’t care because I simply calculate everything in UTC. I just don’t change the time zone of the Pi and it will work. But you could also add or subtract with x hours (maybe with timedelta(hours=x) ) or define the time zone.

My script works with sunrise and sunset. In many cases, the civil twilight would probably be more suitable. But here you can experiment yourself.

My script (Python 3) looks (currently) like this

I let the while loop run every minute, hence the sleep(60) at the end. Since I don’t query the REST API from sunrise-sunset.org on every pass, I could run it more often. But the night light does not need to switch spot on the second.

The last two lines simply check if the string from the current date is different from the one from the URL query. If so, the program simply fetches new data. So, ideally the REST API of the website is queried only once a day.

Maybe checking the status would still be useful. If I get something other than OK, then jump into a loop, wait x seconds and query again.

For the relays this is similar. If they already have the desired status, the script simply jumps one step further.

import requests
import json
from datetime import datetime, time, timedelta
from time import sleep
import pifacedigitalio as p # you only need it if you use PiFace Digital
pifacedigital = p.PiFaceDigital()
url = 'https://api.sunrise-sunset.org/json?lat=51.517576&lng=-0.07978&formatted=0' # URL, change lat and lng
r = requests.get(url) # query data

while True:
    d = datetime.now()
    today_date = d.date() # date today
    time_now = d.time() # time now
    data = json.loads(r.content)
    sunrise = data['results']['sunrise']
    sunset = data['results']['sunset']
    sunrise_time = time(int(sunrise[11:13]), int(sunrise[14:16])) # Change sunrise in time format
    sunset_time = time(int(sunset[11:13]), int(sunset[14:16])) # Change sunset into time format

    if time_now > sunrise_time and time_now < sunset_time: # In between sunrise and sunset

        if pifacedigital.output_pins[1].value == 1: # If relay on, turn it off
            pifacedigital.output_pins[1].turn_off() # turn it off
    else:
        if pifacedigital.output_pins[1].value != 1: # If relay off, turn it on
            pifacedigital.output_pins[1].turn_on() # turn on

    sleep(60)

    if str(sunrise[0:10]) != str(today_date): # different date? Get new data
        r = requests.get(url)

I saved the script as sunrise-sunset.py, made it executable

chmod +x sunrise-sunset.py

and started it on the Raspberry Pi (it runs in the background)

nohup python3 ./sunrise-sunset.py &

You can end it by first finding out the PID (this gives you a number):

pgrep -f sunrise

or you do that

ps -ef | grep "sunrise" | awk '{print $2}'

If you have the correct number you kill the program:

kill <given PID / number>

That works as well

pkill -f sunrise

In my case, this should not cause any problems because there is only one program with the keyword sunrise running.

Alternatively, you could call the program in a screen session and abort it with Ctrl + C if necessary.

Improving the script

The program is not perfect, I know that. For example, it aborts if the URL cannot be reached due to network errors, maintenance work and so on. I can catch the error with except requests.exceptions.ConnectionError. I will add a check if the received data is ok. If there is a network error, just wait x seconds and try again. The URL query would be better in a function I can use.

Furthermore, I would not have to set sunrise and sunset every time the while loop is run. Also here once a day is enough. If you create a function to query the URL, then setting the times would make sense here. I will refine my script while it is running.

Change it as you like

Of course, you can also use sunrise_time and sunset_time to define a time span yourself in which something should happen. Maybe you listen to the radio between 1 and 2 pm. Or take a buzzer and let yourself be woken up for 5 minutes 30 minutes after sunrise.

I’ve been running this for a few days now and it works. It does what it is supposed to do. I am open for suggestions for improvement, because I don’t program that much.

It would also have been possible, I just query the sunrise, switch off the relay, let the program sleep for the length of the daylight and then switch it on again. But I prefer my version, because I can vary more easily with the twilight.

Do you have a Sense HAT? Make a Bitcoin ticker – it’s easy!

Script with gpiozero

For completeness, here is the script of how it might work with gpiozero — GPIO(17) is switched.

import requests
import json
from datetime import datetime, time, timedelta
from time import sleep
from gpiozero import LED

url = 'https://api.sunrise-sunset.org/json?lat=51.517576&lng=-0.07978&formatted=0'
r = requests.get(url)

led = LED(17)

while True:

    d = datetime.now()
    today_date = d.date()
    time_now = d.time()

    data = json.loads(r.content)
    sunrise = data['results']['sunrise']
    sunset = data['results']['sunset']
    sunrise_time = time(int(sunrise[11:13]), int(sunrise[14:16]))
    sunset_time = time(int(sunset[11:13]), int(sunset[14:16]))

    if time_now > sunrise_time and time_now < sunset_time:
        if led.is_active:
            led.off()
    else:
        if not led.is_active:
            led.on()

    sleep(60)

    if str(sunrise[0:10]) != str(today_date):
        r = requests.get(url)

You only have to change the script in a few places and can use it to switch the pins on your Raspberry Pi at sunrise and sunset.

Gpiozero is preinstalled on Raspbian, but not on Raspbian Lite. If you run your Raspberry Pi headless with the Lite version, you may need to install gpiozero first:

sudo apt install python3-gpiozero

Now it works. It’s amazing what you can do with a Raspberry Pi. Do you need more ideas? Why not build a VPN router.

The post Sunrise / Sunset switch Raspberry Pi with Python appeared first on VPN Expert.