Create some Python code that takes photos and sends tweets from the Raspberry Pi!
Connect to Twitter from Python
Boot your Raspberry Pi to the desktop and launch
Because the Raspberry Pi doesn't have a real-time clock, you may need to start by setting the correct date and time on the system.
First lets check the date/time with the command:
If the date looks wrong by more than a few hours, we can set it with this command:
sudo date -s "2 OCT 2014 12:00:00"
This is important, as without the correct time we won't be able to connect to Twitter.
Create a folder for your project with the following command:
Enter this folder with
cd tweeting-babbageand ask a volunteer for the NI Raspberry Jam test account authentication keys:
Lets create the new Python file we will be using:
Launch these Python files in
IDLE3with root permissions (you'll need this for the GPIO) with the command:
sudo idle3 *.py &
auth.pyyou will see the API keys. These are kind of like usernames and passwords, but are designed for computers as they are near impossible to remember:
consumer_key = 'ABCDEFGHIJKLKMNOPQRSTUVWXYZ' consumer_secret = '1234567890ABCDEFGHIJKLMNOPQRSTUVXYZ' access_token = 'ZYXWVUTSRQPONMLKJIHFEDCBA' access_token_secret = '0987654321ZYXWVUTSRQPONMLKJIHFEDCBA'
Now switch over to
babbage.py. Import the
twythonlibrary and the variables from
from twython import Twython from auth import ( consumer_key, consumer_secret, access_token, access_token_secret )
Make a connection with the Twitter API using this set of keys:
twitter = Twython( consumer_key, consumer_secret, access_token, access_token_secret )
main()function which will be called when the script is run. Pick any random message so we can check that your connection to Twitter works:
def main(): message = "Put your own message in here" twitter.update_status(status=message)
This uses the API's
update_status()function to send a tweet containing the text "Hello world!".
We'll also add an instruction at the end to run the
main()method when the script is called directly:
if __name__ == '__main__': main()
Your code should now look like this:
from twython import Twython from auth import ( consumer_key, consumer_secret, access_token, access_token_secret ) twitter = Twython( consumer_key, consumer_secret, access_token, access_token_secret ) def main(): message = "Put your own message in here" twitter.update_status(status=message) print("Tweeted: %s" % message) if __name__ == '__main__': main()
Now save (
Ctrl + S) and run with
F5. You should see the message "Tweeted: Hello world!". Go to your Twitter profile in a web browser to verify it was sent! This will be at
twitter.com/nijamdev, as we are using the
Note that sending multiple tweets with the exact same text are classed as duplicates and rejected by Twitter. If you want to test it again, try tweeting a different message.
If you see an error, your API keys may be incorrect. Be sure to copy them exactly and check the spelling of the variables. You should also check that your Pi is online.
Tweet random messages
Now that we can send some text as a tweet, let's mix it up a bit.
First, import the random module:
This module contains a
choicefunction which takes a list and returns a single entry at random.
Now create a list of messages like so:
messages = [ "Hello world", "Hi there", "My name is Babbage", "What's up?", "How's it going?", "Have you been here before?", "Get a hair cut!", ]
message = "Hello world!"with
message = random.choice(messages).
This chooses a single item from the
messageslist at random.
Run the code again two or more times to see different messages being tweeted at random.
Tweet a picture
Now that the Twitter connection has been tested, let's try to upload a picture. Rather than try to hook up the camera now, we'll test it independently.
Find a picture, copy it to your Raspberry Pi or download it from the internet, and save it to your home folder. Make a note of its location (something like
main()function in the code accordingly:
message = "Hello world - here's a picture!" with open('/home/pi/Downloads/image.jpg', 'rb') as photo: twitter.update_status_with_media(status=message, media=photo)
Make sure to specify the full path to the image correctly.
This opens the file and uses the
update_status_with_media()function to upload the image, along with the tweet text.
Run the code and see if it tweets the text and image together!
Take a picture with the Pi camera
Now that we know we can upload a given picture to Twitter, let's take one with the Pi camera.
With the Pi switched off, connect a Raspberry Pi camera module to the camera port. You may want to ask a volunteer to help you do this.
Boot the Pi and from the command line or LXTerminal test that it works with the command
raspistill -k. If you see the camera's image on the screen, you know it's working. Press
Ctrl + Cto exit the preview.
Now open a new Python window in IDLE3, save as
camera.pyand enter the following code:
from picamera import PiCamera from time import sleep with PiCamera() as camera: camera.start_preview() sleep(3) camera.capture('/home/pi/image.jpg') camera.stop_preview()
This is a test script to check we can take a picture from Python.
F5and you should see a preview on the screen for 3 seconds before the camera takes the picture.
Open the file manager and you should see
image.jpg. Double-click the icon to open it up.
Tweet a picture from the Pi camera
Now we'll copy the
picamera code we just used into the
babbage.py file, so that it will tweet the photo taken by the Pi camera.
First add the
importlines at the top:
from picamera import PiCamera from time import sleep
Imports are best kept at the top of the code before anything else.
Then add the
picameralines in the
with PiCamera() as camera: camera.start_preview() sleep(3) camera.capture('/home/pi/image.jpg') camera.stop_preview() message = "Here's a Pi camera picture!" with open('/home/pi/image.jpg', 'rb') as photo: twitter.update_status_with_media(status=message, media=photo)
Now run the code; it will save the photo to
image.jpgin the home folder and upload it to Twitter.
Check Twitter to see if it worked!
Use a timestamp
Now let's fix the hard-coded filename of
image.jpg and use something more dynamic. It would be better to timestamp the filename so it will never get overwritten. It should also be stored in a folder inside our project.
In the terminal window, create a new folder inside
from datetime import datetime.
Save the timestamp as a variable before taking the picture, and pass this into the path string:
timestamp = datetime.now().isoformat() photo_path = '/home/pi/tweeting-babbage/photos/%s.jpg' % timestamp camera.capture(photo_path)
The timestamp is formatted in the ISO datetime format
2014-10-02T05:10:25.642155(year, month, day, hours, minutes, seconds, microseconds).
Now change the
update_status_with_media()call to this new photo path:
with open(photo_path, 'rb') as photo: twitter.update_status_with_media(status=message, media=photo)
Run the code again; it should save the image in the
tweeting-babbage/photosfolder and tweet it as usual.
- Try adding a text or image overlay to the picture before tweeting! See the picamera documentation http://picamera.readthedocs.org/
- Could you try wiring up a button and using it to twigger a tweet?
- Or even better, use a motion (PIR) sensor to detect movement, then tweet a picture? (might want to check out the parent detector activity for that).
This activity is heavily based off the excellent Tweeting Babbage activity by the Raspberry Pi Foundation, which is released under the Creative Commons Attribution 4.0 International Licence.
The Tweeting Babbage activity can be found at - https://www.raspberrypi.org/learning/tweeting-babbage/