KevinMidboe/python-gpiozero
1
0
Fork 0
mirror of https://github.com/KevinMidboe/python-gpiozero.git synced 2025-10-29 17:50:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rework when_changed attribute to use weakrefs

Browse Source 
Some fairly major changes to ensure that the Pin.when_changed property
doesn't keep references to the objects owning the callbacks that are
assigned. This is vaguely tricky given that ordinary weakref's can't be
used with bound methods (which are ephemeral), so I've back-ported
weakref.WeakMethod from Py3.4.

This solves a whole pile of things like Button instances not
disappearing when they're deleted, and makes composite devices
containing Buttons much easier to construct as we don't need to worry
about partially constructed things not getting deleted.
This commit is contained in:
Dave Jones
2016-10-22 13:55:31 +01:00
parent 08076e8d0e
commit cab6cc8086
7 changed files with 193 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
gpiozero/pins/pi.py
View File

@@ -7,7 +7,12 @@ from __future__ import (
str = type('')
import io
import weakref
from threading import RLock
from weakref import ref, proxy
try:
from weakref import WeakMethod
except ImportError:
from .compat import WeakMethod
import warnings
try:
@@ -186,7 +191,9 @@ class PiPin(Pin):
"""
def __init__(self, factory, number):
super(PiPin, self).__init__()
self._factory = weakref.proxy(factory)
self._factory = proxy(factory)
self._when_changed_lock = RLock()
self._when_changed = None
self._number = number
try:
factory.pi_info.physical_pin(self.address[-1])
@@ -206,3 +213,39 @@ class PiPin(Pin):
def _get_address(self):
return self.factory.address + ('GPIO%d' % self.number,)
def _call_when_changed(self):
method = self.when_changed()
if method is None:
self.when_changed = None
else:
method()
def _get_when_changed(self):
return self._when_changed
def _set_when_changed(self, value):
# Have to take care, if value is either a closure or a bound method,
# not to keep a strong reference to the containing object
with self._when_changed_lock:
if self._when_changed is None and value is not None:
if isinstance(value, MethodType):
self._when_changed = WeakMethod(value)
else:
self._when_changed = ref(value)
self._enable_event_detect()
elif self._when_changed is not None and value is None:
self._disable_event_detect()
self._when_changed = None
elif value is None:
self._when_changed = None
elif isinstance(value, MethodType):
self._when_changed = WeakMethod(value)
else:
self._when_changed = ref(value)
def _enable_event_detect(self):
raise NotImplementedError
def _disable_event_detect(self):
raise NotImplementedError

31
gpiozero/pins/pigpiod.py
View File

@@ -6,9 +6,15 @@ from __future__ import (
)
str = type('')
import weakref
import pigpio
import os
from weakref import proxy
from threading import RLock
try:
from weakref import WeakMethod
except ImportError:
from .compat import WeakMethod
import pigpio
from . import SPI
from .pi import PiPin, PiFactory
@@ -164,6 +170,7 @@ class PiGPIOPin(PiPin):
self._pull = 'up' if factory.pi_info.pulled_up(self.address[-1]) else 'floating'
self._pwm = False
self._bounce = None
self._when_changed_lock = RLock()
self._when_changed = None
self._callback = None
self._edges = pigpio.EITHER_EDGE
@@ -269,26 +276,24 @@ class PiGPIOPin(PiPin):
finally:
self.when_changed = f
def _get_when_changed(self):
if self._callback is None:
return None
return self._callback.callb.func
def _call_when_changed(self, gpio, level, tick):
super(PiGPIOPin, self)._call_when_changed()
def _set_when_changed(self, value):
def _enable_event_detect(self):
self._callback = self.factory.connection.callback(
self.number, self._edges, self._call_when_changed)
def _disable_event_detect(self):
if self._callback is not None:
self._callback.cancel()
self._callback = None
if value is not None:
self._callback = self.factory.connection.callback(
self.number, self._edges,
lambda gpio, level, tick: value())
class PiGPIOHardwareSPI(SPI, Device):
def __init__(self, factory, port, device):
self._port = port
self._device = device
self._factory = weakref.proxy(factory)
self._factory = proxy(factory)
super(PiGPIOHardwareSPI, self).__init__()
self._reserve_pins(*(
factory.address + ('GPIO%d' % pin,)
@@ -382,7 +387,7 @@ class PiGPIOSoftwareSPI(SPI, Device):
self._clock_pin = clock_pin
self._mosi_pin = mosi_pin
self._miso_pin = miso_pin
self._factory = weakref.proxy(factory)
self._factory = proxy(factory)
super(PiGPIOSoftwareSPI, self).__init__()
self._reserve_pins(
factory.pin_address(clock_pin),

33
gpiozero/pins/rpigpio.py
View File

@@ -7,6 +7,14 @@ from __future__ import (
str = type('')
import warnings
from types import MethodType
from threading import RLock
from weakref import ref
try:
from weakref import WeakMethod
except ImportError:
from .compat import WeakMethod
from RPi import GPIO
from .local import LocalPiFactory, LocalPiPin
@@ -89,6 +97,7 @@ class RPiGPIOPin(LocalPiPin):
self._frequency = None
self._duty_cycle = None
self._bounce = -666
self._when_changed_lock = RLock()
self._when_changed = None
self._edges = GPIO.BOTH
GPIO.setup(self.number, GPIO.IN, self.GPIO_PULL_UPS[self._pull])
@@ -202,19 +211,15 @@ class RPiGPIOPin(LocalPiPin):
finally:
self.when_changed = f
def _get_when_changed(self):
return self._when_changed
def _call_when_changed(self, channel):
super(RPiGPIOPin, self)._call_when_changed()
def _set_when_changed(self, value):
if self._when_changed is None and value is not None:
self._when_changed = value
GPIO.add_event_detect(
self.number, self._edges,
callback=lambda channel: self._when_changed(),
bouncetime=self._bounce)
elif self._when_changed is not None and value is None:
GPIO.remove_event_detect(self.number)
self._when_changed = None
else:
self._when_changed = value
def _enable_event_detect(self):
GPIO.add_event_detect(
self.number, self._edges,
callback=self._call_when_changed,
bouncetime=self._bounce)
def _disable_event_detect(self):
GPIO.remove_event_detect(self.number)

42
gpiozero/pins/rpio.py
View File

@@ -8,6 +8,12 @@ str = type('')
import warnings
from threading import RLock
try:
from weakref import WeakMethod
except ImportError:
from .compat import WeakMethod
import RPIO
import RPIO.PWM
from RPIO.Exceptions import InvalidChannelException
@@ -83,6 +89,7 @@ class RPIOPin(LocalPiPin):
self._pwm = False
self._duty_cycle = None
self._bounce = None
self._when_changed_lock = RLock()
self._when_changed = None
self._edges = 'both'
try:
@@ -191,25 +198,20 @@ class RPIOPin(LocalPiPin):
finally:
self.when_changed = f
def _get_when_changed(self):
return self._when_changed
def _call_when_changed(self, channel, value):
super(RPIOPin, self)._call_when_changed()
def _set_when_changed(self, value):
if self._when_changed is None and value is not None:
self._when_changed = value
RPIO.add_interrupt_callback(
self.number,
lambda channel, value: self._when_changed(),
self._edges, self.GPIO_PULL_UPS[self._pull], self._bounce)
elif self._when_changed is not None and value is None:
try:
RPIO.del_interrupt_callback(self.number)
except KeyError:
# Ignore this exception which occurs during shutdown; this
# simply means RPIO's built-in cleanup has already run and
# removed the handler
pass
self._when_changed = None
else:
self._when_changed = value
def _enable_event_detect(self):
RPIO.add_interrupt_callback(
self.number, self._call_when_changed, self._edges,
self.GPIO_PULL_UPS[self._pull], self._bounce)
def _disable_event_detect(self):
try:
RPIO.del_interrupt_callback(self.number)
except KeyError:
# Ignore this exception which occurs during shutdown; this
# simply means RPIO's built-in cleanup has already run and
# removed the handler
pass