def get_raw_data(self):
logger.debug('Using RPICAM')
power_mngt = None
if ',' in self.location:
power_mngt = self.location.split(',')[1]
# Some kind of 'power management' with the last gpio pin number :)
logger.debug('Enabling IR LED for webcam \'{}\' with GPIO power pin {}'.format(self.get_name(),power_mngt))
GPIO.setup(terrariumUtils.to_BCM_port_number(power_mngt), GPIO.OUT)
sleep(0.1)
stream = BytesIO()
try:
with PiCameraUpstream(resolution=(self.resolution['width'], self.resolution['height'])) as camera:
camera.awb_mode = self.get_awb()
logger.debug('Open rpicam')
camera.start_preview()
logger.debug('Wait %s seconds for preview' % (terrariumWebcamSource.WARM_UP,))
time.sleep(terrariumWebcamSource.WARM_UP)
logger.debug('Save rpicam to jpeg')
camera.capture(stream, format='jpeg')
logger.debug('Done creating RPICAM image')
self.raw_image = stream
if power_mngt:
# Shutdown the IR LEDS when done
logger.debug('Shutting down IR LEDS for webcam {}'.format(self.get_name()))
GPIO.cleanup(terrariumUtils.to_BCM_port_number(power_mngt))
return True
except PiCameraError:
logger.exception('Error getting raw RPI image from webcam \'%s\' with error message:' % (self.get_name(),))
return False
def open(self):
try:
gpio_pins = self.get_address().split(',')
logger.debug('Open sensor type \'{}\' with address {}'.format(
self.get_type(), gpio_pins))
if len(gpio_pins) > 1 and terrariumUtils.to_BCM_port_number(
gpio_pins[-1]):
# Some kind of 'power management' with the last gpio pin number :) https://raspberrypi.stackexchange.com/questions/68123/preventing-corrosion-on-yl-69
logger.debug(
'Enabling power control management on sensor type \'{}\' with GPIO power pin {}'
.format(self.get_type(), gpio_pins[-1]))
GPIO.setup(terrariumUtils.to_BCM_port_number(gpio_pins[-1]),
GPIO.OUT)
sleep(0.5)
GPIO.setup(terrariumUtils.to_BCM_port_number(gpio_pins[0]),
GPIO.IN)
except Exception as ex:
logger.warning(
'Error opening {} sensor \'{}\'. Error message: {}'.format(
self.get_type(), self.get_name(), ex))
return False
return True
def load_raw_data(self):
data = None
try:
gpio_pins = self.get_address().split(',')
data = {}
GPIO.output(terrariumUtils.to_BCM_port_number(gpio_pins[0]), False)
sleep(2)
GPIO.output(terrariumUtils.to_BCM_port_number(gpio_pins[0]), True)
sleep(0.00001)
GPIO.output(terrariumUtils.to_BCM_port_number(gpio_pins[0]), False)
pulse_start = time()
while GPIO.input(terrariumUtils.to_BCM_port_number(
gpio_pins[1])) == 0:
pulse_start = time()
pulse_end = time()
while GPIO.input(terrariumUtils.to_BCM_port_number(
gpio_pins[1])) == 1:
pulse_end = time()
pulse_duration = pulse_end - pulse_start
# https://www.modmypi.com/blog/hc-sr04-ultrasonic-range-sensor-on-the-raspberry-pi
# Measure in centimetre
data = {self.get_sensor_type(): round(pulse_duration * 17150, 5)}
except Exception as ex:
pass
return data
def _load_hardware(self):
address = self._address
if len(address) >= 2 and terrariumUtils.is_float(address[1]):
# Set / enable power management
self._device['power_mngt'] = terrariumUtils.to_BCM_port_number(address[1])
GPIO.setup(terrariumUtils.to_BCM_port_number(address[0]), GPIO.IN) # Data in
return terrariumUtils.to_BCM_port_number(address[0])
def __dim_switch(self,from_value,to_value,duration):
# When the dimmer is working, ignore new state changes.
if not self.__dimmer_running:
self.__pigpio.set_pull_up_down(terrariumUtils.to_BCM_port_number(self.get_address()), pigpio.PUD_OFF)
self.__dimmer_running = True
if from_value is None or duration == 0:
logger.info('Switching dimmer \'%s\' from %s%% to %s%% instantly',
self.get_name(),from_value,to_value)
# No dimming, straight to_value
if 'pwm-dimmer' == self.get_hardware_type():
dim_value = terrariumSwitch.PWM_DIMMER_MAXDIM * ((100.0 - float(to_value)) / 100.0)
dim_freq = terrariumSwitch.PWM_DIMMER_FREQ
elif 'dc-dimmer' == self.get_hardware_type():
dim_value = terrariumSwitch.DC_DIMMER_MAXDIM * (float(to_value) / 100.0)
dim_freq = terrariumSwitch.DC_DIMMER_FREQ
self.__pigpio.hardware_PWM(terrariumUtils.to_BCM_port_number(self.get_address()), dim_freq, int(dim_value) * 1000) # 5000Hz state*1000% dutycycle
else:
from_value = float(from_value)
to_value = float(to_value)
direction = (1.0 if from_value < to_value else -1.0)
logger.info('Changing dimmer \'%s\' from %s%% to %s%% in %s seconds',self.get_name(),from_value,to_value,duration)
distance = abs(from_value - to_value)
if duration == 0.0 or distance == 0.0:
steps = 1.0
else:
steps = math.floor(min( (abs(duration) / terrariumSwitch.DIMMER_MIN_TIMEOUT),
(distance / terrariumSwitch.DIMMER_MIN_STEP)))
distance /= steps
duration /= steps
logger.debug('Dimmer settings: Steps: %s, Distance per step: %s%%, Time per step: %s, Direction: %s',steps, distance, duration, direction)
for counter in range(int(steps)):
from_value += (direction * distance)
if 'pwm-dimmer' == self.get_hardware_type():
dim_value = terrariumSwitch.PWM_DIMMER_MAXDIM * ((100.0 - from_value) / 100.0)
dim_freq = terrariumSwitch.PWM_DIMMER_FREQ
elif 'dc-dimmer' == self.get_hardware_type():
dim_value = terrariumSwitch.DC_DIMMER_MAXDIM * (float(to_value) / 100.0)
dim_freq = terrariumSwitch.DC_DIMMER_FREQ
logger.debug('Dimmer animation: Step: %s, value %s%%, Dim value: %s, timeout %s',counter+1, from_value, dim_value, duration)
self.__pigpio.hardware_PWM(terrariumUtils.to_BCM_port_number(self.get_address()), dim_freq, int(dim_value) * 1000) # 5000Hz state*1000% dutycycle
sleep(duration)
# For impatient people... Put the dimmer at the current state value if it has changed during the animation (DISABLED FOR NOW)
# dim_value = terrariumSwitch.PWM_DIMMER_MAXDIM * ((100.0 - self.get_state()) / 100.0)
# self.__pigpio.hardware_PWM(terrariumUtils.to_BCM_port_number(self.get_address()), 5000, int(dim_value) * 1000) # 5000Hz state*1000% dutycycle
self.__dimmer_running = False
logger.info('Dimmer \'%s\' is done at value %s%%',self.get_name(),self.get_state())
else:
logger.warning('Dimmer %s is already working. Ignoring state change!. Will switch to latest state value when done', self.get_name())
def close(self):
logger.debug('Close sensor type \'%s\' with address %s' %
(self.__class__.__name__, self.__datapin))
GPIO.cleanup(terrariumUtils.to_BCM_port_number(self.__datapin))
if self.__powerpin is not None:
logger.debug(
'Close power control pin of sensor type \'%s\' with address %s'
% (self.__class__.__name__, self.__powerpin))
GPIO.cleanup(terrariumUtils.to_BCM_port_number(self.__powerpin))
def set_hardware_state(self, state, force=False):
if self.get_type() == terrariumPowerSwitchGPIO.TYPE:
GPIO.output(
terrariumUtils.to_BCM_port_number(self.get_address()),
(GPIO.HIGH if state is terrariumPowerSwitch.ON else GPIO.LOW))
elif self.get_type() == terrariumPowerSwitchGPIOInverse.TYPE:
GPIO.output(
terrariumUtils.to_BCM_port_number(self.get_address()),
(GPIO.LOW if state is terrariumPowerSwitch.ON else GPIO.HIGH))
def __enter__(self):
"""used to enable python's with statement support"""
GPIO.setup(terrariumUtils.to_BCM_port_number(self.__datapin), GPIO.IN)
if self.__powerpin is not None:
# Some kind of 'power management' :) https://raspberrypi.stackexchange.com/questions/68123/preventing-corrosion-on-yl-69
logger.debug('Enabling power control management on sensor type \'%s\' with GPIO power address %s' % (self.__class__.__name__,self.__powerpin))
GPIO.setup(terrariumUtils.to_BCM_port_number(self.__powerpin), GPIO.OUT)
return self
def _load_hardware(self):
address = self._address
if len(address) >= 2 and terrariumUtils.is_float(address[1]):
# Set / enable power management
self._device['power_mngt'] = terrariumUtils.to_BCM_port_number(address[1])
if self.HARDWARE == terrariumDHT11Sensor.HARDWARE:
device = DHT11(terrariumUtils.to_BCM_port_number(address[0]))
elif self.HARDWARE in [terrariumDHT22Sensor.HARDWARE, terrariumAM2302Sensor.HARDWARE]:
device = DHT22(terrariumUtils.to_BCM_port_number(address[0]))
return device
def __dim_switch(self,value,duration):
# When the dimmer is working, ignore new state changes.
if not self.__dimmer_running:
self.__dimmer_running = True
self.__dimmer_state = (0.0 if not terrariumUtils.is_float(self.get_state()) else float(self.get_state()))
value = (0.0 if not terrariumUtils.is_float(value) else float(value))
duration = (0.0 if not terrariumUtils.is_float(duration) else float(duration))
direction = (1.0 if self.__dimmer_state <= value else -1.0)
distance = abs(self.__dimmer_state - value)
if int(duration) == 0 or int(distance) == 0:
steps = 1.0
else:
steps = math.floor(min( (abs(duration) / terrariumPowerDimmerSource.DIMMER_MIN_TIMEOUT),
(distance / terrariumPowerDimmerSource.DIMMER_MIN_STEP)))
distance /= steps
duration /= steps
logger.debug('Dimmer settings: Steps: %s, Distance per step: %s%%, Time per step: %s, Direction: %s',steps, distance, duration, direction)
for counter in range(int(steps)):
self.__dimmer_state += (direction * distance)
if self.get_type() == terrariumPowerDimmerPWM.TYPE:
dim_value = terrariumPowerDimmerPWM.DIMMER_MAXDIM * ((100.0 - float(self.__dimmer_state)) / 100.0)
dim_freq = terrariumPowerDimmerPWM.DIMMER_FREQ
elif self.get_type() == terrariumPowerDimmerDC.TYPE:
dim_value = terrariumPowerDimmerDC.DIMMER_MAXDIM * (float(self.__dimmer_state) / 100.0)
dim_freq = terrariumPowerDimmerDC.DIMMER_FREQ
for gpiopin in self.get_address().split(','):
if terrariumUtils.to_BCM_port_number(gpiopin) is False:
continue
logger.debug('Dimmer animation: Step: %s, value %s%%, Dim value: %s, timeout %s',counter+1, self.__dimmer_state, dim_value, duration)
self.__pigpio.hardware_PWM(terrariumUtils.to_BCM_port_number(gpiopin), dim_freq, int(dim_value) * 1000) # 5000Hz state*1000% dutycycle
if duration > 0.0:
sleep(duration)
# For impatient people... Put the dimmer at the current state value if it has changed during the animation (DISABLED FOR NOW)
# dim_value = terrariumSwitch.PWM_DIMMER_MAXDIM * ((100.0 - self.get_state()) / 100.0)
# self.__pigpio.hardware_PWM(terrariumUtils.to_BCM_port_number(self.get_address()), 5000, int(dim_value) * 1000) # 5000Hz state*1000% dutycycle
self.__dimmer_state = value
self.__dimmer_running = False
if self.callback is not None:
self.callback(self.get_data())
logger.info('Power switch \'{}\' at address \'{}\' is done at value {}% in {} seconds'.format(self.get_name(),
self.get_address(),
self.get_state(),
duration*steps))
def __get_raw_data(self):
if self.__powerpin is not None:
logger.debug('Powering up sensor type \'%s\' with GPIO address %s' % (self.__class__.__name__,self.__powerpin))
GPIO.output(terrariumUtils.to_BCM_port_number(self.__powerpin),1)
# Time to get power flowing. Not sure what the right amount time would be....
sleep(0.5)
self.__value = GPIO.input(terrariumUtils.to_BCM_port_number(self.__datapin))
logger.debug('Read state sensor type \'%s\' with GPIO address %s with current alarm: %s' % (self.__class__.__name__,self.__datapin,self.__value))
if self.__powerpin is not None:
logger.debug('Powering down sensor type \'%s\' with GPIO address %s' % (self.__class__.__name__,self.__powerpin))
GPIO.output(terrariumUtils.to_BCM_port_number(self.__powerpin),0)
def set_notification_leds(self,green,orange,red):
self.__notification_leds['info']['pin'] = None if green is None else terrariumUtils.to_BCM_port_number(green)
self.__notification_leds['warning']['pin'] = None if orange is None else terrariumUtils.to_BCM_port_number(orange)
self.__notification_leds['error']['pin'] = None if red is None else terrariumUtils.to_BCM_port_number(red)
# Initialize leds and run them all for 1 second to test
GPIO.setmode(GPIO.BCM)
for messagetype in ['info','warning','error']:
lednr = self.__notification_leds[messagetype]['pin']
if lednr is not None:
GPIO.setup(lednr, GPIO.OUT)
GPIO.output(lednr,1)
sleep(1)
GPIO.output(lednr,0)
def __checker(self):
logger.info('Start terrariumPI door checker for door \'%s\'' % self.get_name())
while True:
current_status = None
if self.get_hardware_type() == 'gpio':
current_status = terrariumDoor.OPEN if GPIO.input(terrariumUtils.to_BCM_port_number(self.get_address())) else terrariumDoor.CLOSED
elif self.get_hardware_type() == 'remote' and (int(time.time()) - self.__last_check) >= terrariumDoor.REMOTE_TIMEOUT:
current_status = None
url_data = terrariumUtils.parse_url(self.get_address())
if url_data is False:
logger.error('Remote url \'%s\' for door \'%s\' is not a valid remote source url!' % (self.get_address(),self.get_name()))
else:
data = terrariumUtils.get_remote_data(self.get_address())
if data is not None:
current_status = terrariumDoor.OPEN if terrariumUtils.is_true(data) else terrariumDoor.CLOSED
else:
logger.warning('Remote door \'%s\' got error from remote source \'%s\'' % (self.get_name(),self.get_address()))
self.__last_check = int(time.time())
logger.debug('Current door \'%s\' status: %s' % (self.get_name(),current_status))
if current_status != self.get_status():
logger.info('Door \'%s\' changed from %s to %s' % (self.get_name(),self.get_status(), current_status))
self.set_status(current_status)
if self.callback is not None:
self.callback(self.get_data())
sleep(terrariumDoor.CHECKER_TIMEOUT)
def load_hardware(self): address = self._address self._device['device'] = terrariumUtils.to_BCM_port_number(address[0]) GPIO.setup(self._device['device'], GPIO.IN, pull_up_down=GPIO.PUD_UP) # Data in self._load_hardware() self._checker['thread'] = threading.Thread(target=self._run) self._checker['thread'].start()
def __init__(self, triggerpin, echopin, powerpin=None):
super(terrariumHCSR04Sensor, self).__init__(echopin, powerpin)
GPIO.setup(terrariumUtils.to_BCM_port_number(triggerpin), GPIO.OUT)
#ECHO pin is done at super()
self.__datapin = echopin
self.__triggerpin = triggerpin
self.__value = None
def close(self):
super(terrariumHCSR04Sensor, self).close()
try:
gpio_pins = self.get_address().split(',')
if len(gpio_pins) > 2 and terrariumUtils.to_BCM_port_number(
gpio_pins[1]):
logger.debug(
'Closeing trigger control pin of sensor type \'{}\' at GPIO power pin {}'
.format(self.get_type(), gpio_pins[1]))
GPIO.cleanup(terrariumUtils.to_BCM_port_number(gpio_pins[1]))
except Exception as ex:
logger.warning(
'Error closing {} sensor \'{}\'. Error message: {}'.format(
self.get_type(), self.get_name(), ex))
def __init__(self, datapin, powerpin=None):
self.__datapin = datapin
self.__powerpin = powerpin
self.__value = None
logger.debug('Initializing sensor type \'%s\' with GPIO address %s' %
(self.__class__.__name__, self.__datapin))
#GPIO.setup(terrariumUtils.to_BCM_port_number(self.__datapin), GPIO.IN,pull_up_down=GPIO.PUD_UP)
GPIO.setup(terrariumUtils.to_BCM_port_number(self.__datapin), GPIO.IN)
if self.__powerpin is not None:
# Some kind of 'power management' :) https://raspberrypi.stackexchange.com/questions/68123/preventing-corrosion-on-yl-69
logger.debug(
'Enabling power control management on sensor type \'%s\' with GPIO power address %s'
% (self.__class__.__name__, self.__powerpin))
GPIO.setup(terrariumUtils.to_BCM_port_number(self.__powerpin),
GPIO.OUT)
def set_address(self, address):
# Can't set OWFS or W1 sensor addresses. This is done by the OWFS software or kernel OS
if self.get_hardware_type() not in ['owfs', 'w1']:
self.sensor_address = address
if 'hc-sr04' == self.get_hardware_type() and ',' in address:
sensor = address.split(',')
self.sensor_address = {'TRIG': sensor[0], 'ECHO': sensor[1]}
try:
GPIO.setup(
terrariumUtils.to_BCM_port_number(
self.sensor_address['TRIG']), GPIO.OUT)
GPIO.setup(
terrariumUtils.to_BCM_port_number(
self.sensor_address['ECHO']), GPIO.IN)
except Exception, err:
logger.warning(err)
pass
def load_hardware(self):
self.__dimmer_running = False
pigpio.exceptions = False
self.__pigpio = pigpio.pi('localhost')
if not self.__pigpio.connected:
self.__pigpio = pigpio.pi()
if not self.__pigpio.connected:
logger.error('PiGPIOd process is not running')
self.__pigpio = False
pigpio.exceptions = True
self.__pigpio.set_pull_up_down(terrariumUtils.to_BCM_port_number(self.get_address()), pigpio.PUD_OFF)
def __get_raw_data(self):
GPIO.output(terrariumUtils.to_BCM_port_number(self.__triggerpin),
False)
time.sleep(2)
GPIO.output(terrariumUtils.to_BCM_port_number(self.__triggerpin), True)
time.sleep(0.00001)
GPIO.output(terrariumUtils.to_BCM_port_number(self.__triggerpin),
False)
pulse_start = time.time()
while GPIO.input(terrariumUtils.to_BCM_port_number(
self.__datapin)) == 0:
pulse_start = time.time()
pulse_end = time.time()
while GPIO.input(terrariumUtils.to_BCM_port_number(
self.__datapin)) == 1:
pulse_end = time.time()
pulse_duration = pulse_end - pulse_start
# https://www.modmypi.com/blog/hc-sr04-ultrasonic-range-sensor-on-the-raspberry-pi
# Measure in centimetre
self.__value = round(pulse_duration * 17150, 5)
def __get_raw_data(self, force_update=False):
# Need some extra timeout to get the chip to relax....:(
starttime = int(time.time())
if force_update or starttime - self.__cached_data[
'last_update'] > terrariumDHTSensor.__CACHE_TIMEOUT:
#sleep(2.1)
self.__cached_data['humidity'], self.__cached_data[
'temperature'] = Adafruit_DHT.read_retry(
self.__dhttype,
terrariumUtils.to_BCM_port_number(self.__datapin), 5)
self.__cached_data['last_update'] = starttime
def _load_hardware(self):
address = self._address
pi = pigpio.pi()
self._trig = terrariumUtils.to_BCM_port_number(address[0])
self._echo = terrariumUtils.to_BCM_port_number(address[1])
self._ping = False
self._high = None
self._time = None
self._triggered = False
self._trig_mode = pi.get_mode(self._trig)
self._echo_mode = pi.get_mode(self._echo)
pi.set_mode(self._trig, pigpio.OUTPUT)
pi.set_mode(self._echo, pigpio.INPUT)
self._cb = pi.callback(self._trig, pigpio.EITHER_EDGE, self._cbf)
self._cb = pi.callback(self._echo, pigpio.EITHER_EDGE, self._cbf)
return pi
def load_raw_data(self):
data = None
try:
gpio_pins = self.get_address().split(',')
data = {}
GPIO.output(terrariumUtils.to_BCM_port_number(gpio_pins[0]), False)
sleep(2)
GPIO.output(terrariumUtils.to_BCM_port_number(gpio_pins[0]), True)
sleep(0.00001)
GPIO.output(terrariumUtils.to_BCM_port_number(gpio_pins[0]), False)
pulse_start = time()
starttime = pulse_start
while GPIO.input(terrariumUtils.to_BCM_port_number(
gpio_pins[1])) == 0:
pulse_start = time()
# Somehow, sometimes this will end in an endless loop. The value will never go to '0' (zero). So wrong measurement and return none...
if pulse_start - starttime > 2:
logger.warn(
'Sensor {} \'{}\' is failing to get in the right state. Abort!'
.format(self.get_type(), self.get_name()))
return data
pulse_end = time()
while GPIO.input(terrariumUtils.to_BCM_port_number(
gpio_pins[1])) == 1:
pulse_end = time()
pulse_duration = pulse_end - pulse_start
# https://www.modmypi.com/blog/hc-sr04-ultrasonic-range-sensor-on-the-raspberry-pi
# Measure in centimetre
data = {self.get_sensor_type(): round(pulse_duration * 17150, 5)}
except Exception as ex:
pass
return data
def load_raw_data(self):
try:
gpio_pins = self.get_address().split(',')
data = GPIO.input(terrariumUtils.to_BCM_port_number(gpio_pins[0]))
logger.debug(
'Read state sensor type \'{}\' with GPIO address {} with current alarm: {}'
.format(self.get_type(), gpio_pins[0], data))
except Exception as ex:
logger.warning(
'Error reading new data from {} sensor \'{}\'. Error message: {}'
.format(self.get_type(), self.get_name(), ex))
return False
return data
def __init__(self,
sensor_id,
sensor_type,
address,
name='',
callback_indicator=None):
super(terrariumGPIOSensor,
self).__init__(sensor_id, sensor_type, address, name,
callback_indicator)
gpio_pins = self.get_address().split(',')
logger.debug(
'Initializing sensor type \'%s\' with GPIO address %s'.format(
self.get_type(), gpio_pins))
GPIO.setup(terrariumUtils.to_BCM_port_number(gpio_pins[0]),
GPIO.IN,
pull_up_down=GPIO.PUD_UP)
def set_address(self, address):
self.sensor_address = address
if 'eg-pm-usb' in self.get_hardware_type():
self.device = (int(self.sensor_address) - 1) / 4
elif 'eg-pm-lan' in self.get_hardware_type():
# Input format should be either:
# - http://[HOST]#[POWER_SWITCH_NR]
# - http://[HOST]/#[POWER_SWITCH_NR]
# - http://[PASSWORD]@[HOST]#[POWER_SWITCH_NR]
# - http://[PASSWORD]@[HOST]/#[POWER_SWITCH_NR]
data = re.match(
r"^http:\/\/((?P<passwd>[^@]+)@)?(?P<host>[^#\/]+)(\/)?#(?P<switch>[1-4])$",
self.sensor_address)
if data:
data = data.groupdict()
if 'passwd' not in data:
data['passwd'] = ''
# https://github.com/perryflynn/energenie-connect0r
self.device = energenieconnector.EnergenieConnector(
'http://' + data['host'], data['passwd'])
status = self.device.getstatus()
if status['login'] == 1:
if self.device.login():
logger.info(
'Connection to remote Energenie LAN \'%s\' is successfull at location %s'
% (self.get_name(), self.sensor_address))
status = self.device.getstatus()
if status['login'] != 0:
logger.error(
'Could not login to the Energenie LAN device %s at location %s. Error status %s(%s)'
% (self.get_name(), self.sensor_address,
status['logintxt'], status['login']))
self.device = None
elif 'gpio' in self.get_hardware_type():
try:
GPIO.setup(
terrariumUtils.to_BCM_port_number(self.get_address()),
GPIO.OUT)
except Exception, err:
logger.warning(err)
pass
def __checker(self):
logger.info('Start terrariumPI door checker for door \'%s\'' %
self.get_name())
while True:
if self.get_hardware_type() == 'gpio':
current_status = terrariumDoor.OPEN if GPIO.input(
terrariumUtils.to_BCM_port_number(
self.get_address())) else terrariumDoor.CLOSED
logger.debug('Current door \'%s\' status: %s' %
(self.get_name(), current_status))
if current_status != self.get_status():
logger.info(
'Door \'%s\' changed from %s to %s' %
(self.get_name(), self.get_status(), current_status))
self.set_status(current_status)
if self.callback is not None:
self.callback(self.get_data())
sleep(terrariumDoor.CHECKER_TIMEOUT)
def load_raw_data(self):
data = None
try:
gpio_pins = self.get_address().split(',')
data = {}
sensor_device = Adafruit_DHT.DHT11
if terrariumDHT22Sensor.TYPE == self.get_type():
sensor_device = Adafruit_DHT.DHT22
elif terrariumAM2302Sensor.TYPE == self.get_type():
sensor_device = Adafruit_DHT.AM2302
data['humidity'], data['temperature'] = Adafruit_DHT.read_retry(
sensor_device, terrariumUtils.to_BCM_port_number(gpio_pins[0]),
4)
except Exception as ex:
logger.warning(
'Error getting new data from {} sensor \'{}\'. Error message: {}'
.format(self.get_type(), self.get_name(), ex))
return data
def stop(self): GPIO.cleanup(terrariumUtils.to_BCM_port_number(self.get_address())) super(terrariumPowerSwitchGPIO,self).stop()
def load_hardware(self): GPIO.setup(terrariumUtils.to_BCM_port_number(self.get_address()), GPIO.OUT)
