Raspberry Pi GPIO safe clean up

Question

We are always told to call GPIO.cleanup() before we exit our Pi programs. I've seen people using try ... catch ... finally to achieve this. But hey, we are doing python here, an elegant programming language. Do you guys think this is a more elegant solution?

# SafeGPIO.py
from RPi import GPIO
class SafeGPIO(object):
 def __enter__(self):
 return GPIO
 def __exit__(self, *args, **kwargs):
 GPIO.cleanup()

Use like this:

from SafeGPIO import SafeGPIO
import time
with SafeGPIO() as GPIO:
 GPIO.setmode(GPIO.BOARD)
 GPIO.setup(7, GPIO.OUT)
 GPIO.output(7, True)
 GPIO.setup(8, GPIO.OUT)
 GPIO.output(8, True)
 val = 0
 for i in xrange(10):
 val = (val + 1) % 2
 active_pin = 7 + val
 inactive_pin = 7 + (val + 1) % 2
 GPIO.output(active_pin,True)
 GPIO.output(inactive_pin,False)
 time.sleep(2)

• Quill: Unfortunately, updating the code in your questions after receiving answers is against site policy. See What do after receiving answers for more information.
• rabbit.aaron: Just to state that, the purpose of creating this context manager is not just to ensure cleanup on exit, but to ensure cleanup when program exits the with block. We might need to use cleanupmultiple times. Whereas at_exit only run once on program exit.
• rabbit.aaron: I have also created a decorator for this purpose, available here

Answer 1

Intuitively I think that I don't like to encapsulate all of my program in a with SafeGPIO() as GPIO call, so I searched the library and found at_exit. Using this you should be able to have something like the following in SafeGPIO.py:

import at_exit
from RPi import GPIO as RPi_GPIO
# Something useful to re-export GPIO?! Possibly the following?
GPIO = RPi_GPIO
@atexit.register
def cleanup():
 RPI_GPIO.cleanup()

Not sure on how to re-export the GPIO, but if this construct works you only need to do from SafeGPIO import GPIO, and then when Python exits it will call the original GPIO.cleanup().

Now the real question is why don't the RPi module automatically do this if this is a best practice when using RPi? Sadly, I don't know the answer to that, but it could be a reason for it, which might affect whether this is actually a good solution or not.

_{PS! I've addressed some more variants related to how to do cleanup in this answer, where I also focus a little more on choosing different options related to use cases.}

• rabbit.aaron: Well, I'm a programmer, new to Raspberry Pi, but opening pins feels like opening files to me. And in python you use with open('filename','rb') as myfile: to wrap around your file read so you always close the file.
• rabbit.aaron: And also, my code is not limited to clean up pins on exit, also u can use it to clean up pins in a function or half way in your code. To avoid wrapping all your code in the SafeGPIO, you can have your code in a function, then wrap that function call in SafeGPIO(). I like the idea of using a decorator. I will create a decorator version of it as well. Maybe put it up in github.
• SuperBiasedMan: Are you sure this is as safe as using with? There are exceptions listed there where at_exit isn't being called, though admittedly I'm not sure when with doesn't call __exit__ correctly.
• rabbit.aaron: Unless python crashes, otherwise with catches all exceptions. That's why they use with open(...) to read / write files.
• holroy: @rabbit.aaron, I've written an extended version of this answer on your followup question, trying to highlight some of the different aspects of various alternatives.