Predict the weather using your Raspberry Pi
1 PULLING PYTHON AROUND The Maker Life kit (which, it seems, has been discontinued) pulls in its data using a couple of Python libraries. The same is likely true for most Raspberry Pi weather sensors. This is a good thing—Python being the LEGO-esque coding toolkit that it is, it’s likely that any sensor you pick up will integrate with any programs you happen to write, as long as you import the appropriate libraries. And this gives us a number of opportunities.
>> We could, at the most basic level, pipe this raw output not straight on to the screen, but into a text file, which we can process later to spot trends. This is easy enough: Taking the code obtained by our weather station, we first add a line outside the main loop to open a file in append mode—something along the lines of f = open (“weather.txt”, “a”) , then replace any instances where it would print to screen with code such as
f.write(“< weather data>”) , with the data being whatever our code had originally pulled out. Be sure to use
f.close() to cap off the file when you’re done with it. >> With more tweaking and a little formatting, you could turn that output into a comma separated file, suitable for importing directly into a spreadsheet and transforming into graphs. Obviously, you need to be a little careful with your storage here, and consider whether you want to write out with such frequency, given that a Raspberry Pi tends to run from a rather fragile SD card.
2 USING WEATHER LISTS You could, instead, append that data to a Python list to reduce the number of writes you need to make. Start by creating an empty list variable with
weatherlist = [] . Add a counter variable (you’re going to use i because, well, that’s the done thing) to control both where in that list the data is going to be put, and the frequency that you’ll output that data to a file, add one to the counter each time the loop goes through, and switch out your existing f.write or print statements for
weatherlist.insert(i, < weather data>) statements, which will build your list as it goes.
When your counter reaches an appropriate value, use your preferred write method to output the contents of your list to a file. We suggest joining the list items together, dropping it as a single chunk (closing the file by
using with ), then resetting the list and counter:
with open(‘weather.txt’, ‘a’) as f:
f.write(w_string)
This is very basic, inelegant code. You can, no doubt, do better. Now, we’re not casting any aspersions here, but it’s fair to say that the sensors that your weather station carries are, unless you’ve gone a little crazy with the spending, likely not dragging in every single weather metric that matters. Maybe you don’t even have any weather station gear, you poor thing. Luckily, we can get modular here, too—both Yahoo ( https://pypi.org/project/ weather-api) and the excellent DarkSky ( https://github.com/
ZeevG/python-forecast.io) [ Image B] offer up live and localized data, which you can import and process yourself.
3 DARK SKIES ARE FORECAST Let’s look at the latter. Go to https://darksky.net/dev, hit the button, and get yourself an API key, which is required to tap into the data. It’s free unless you’re a heavy user—you get 1,000 API calls per day, and they’re charged at a nominal rate after that. Next, jump into a terminal, and download the relevant wrapper through pip by using:
install pip install python-forecastio
Once it’s installed, pulling that data in is relatively straightforward. At the beginning of your chunk of Python code, add in the relevant libraries with import forecastio , then add some variables just below; api_key = “< your api key>” keeps that key (which you’ll need to pass to the main function) handy, while lat = <latitude> and lon = <longtitude> store your precise location, useful for making the most of DarkSky’s hyperlocal forecasting. If you (somehow!) don’t already know your latitude and longtitude, www.latlong.net can connect you to an OpenStreetMap instance that’ll cough up the goods [ Image C].
With the prerequisites written in, you can create a forecast object using the following line:
forecast = forecastio.load_ forecast(api_ key, lat, lon)
This puts a whole wedge of data, and the relevant methods to extract it, into the forecast object; pull from it by, for example, adding the following (or a more graceful version of it): weatherHour= forecast.hourly() print weatherHour.summary print weatherHour.icon
There are tons more options to exploit, if you’re after a particular metric, a particular timescale, or anything else. That forecast object also includes daily() , minutely() , and currently() methods, and you can use
forecast.update() to refresh the object with the latest info. That raw data is stored in the data portion of the DataBlock—do with that what you will.
If you want to play with DarkSky using a different language, you can—there are wrappers for everything from Python 2 and 3 to Ruby, PHP, and more to be found at https://darksky.net/dev/docs/libraries.
Finally, if, having read this far, you’re now looking for a quick and affordable way to set up your own weather station, devices such as the Flotilla [ Image D] (which we wouldn’t necessarily leave outside) can get you started for as little as $8. Have fun watching the skies.