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)