def get_voltage(id): """Get the voltage. :param string id: The ID of the voltage type to get (core, sdram_c, etc). :returns: The voltage. :rtype: int, long :raises: raspy.invalid_operation_exception.InvalidOperationException if invalid command ("measure_volts") or response. """ cmd = "/opt/vc/bin/vcgencmd measure_volts " + id result = exec_utils.execute_command(cmd) if result is not None: val = -1 separators = ["\\\[", "\\\=", "\\\V", "\\\]"] # noinspection PyTypeChecker for i, line in enumerate(result): parts = re.split('|'.join(map(re.escape, separators)), line) try: val = float(parts[1]) except ValueError: val = -1 return val raise InvalidOperationException("Invalid command or response.")
def state(self, pwr_state): """Set the state of the power component. :param int pwr_state: The state to set. :raises: raspy.object_disposed_exception.ObjectDisposedException if this instance has been disposed. :raises: raspy.io.invalid_pin_mode_exception.InvalidPinModeException if the pin being used to control this device is not configure as an output. :raises: raspy.invalid_operation_exception.InvalidOperationException if an invalid state is specified. """ if self.is_disposed: raise ObjectDisposedException("GpioPowerComponent") if self.__output.mode != pin_mode.OUT: msg = "Pins in use by power components MUST be configured as " msg += "outputs." raise InvalidPinModeException(msg, self.__output) if pwr_state == power_state.OFF: self.__output.write(self.__offState) pwr.PowerInterface.state.fset(self, pwr_state) elif pwr_state == power_state.ON: self.__output.write(self.__onState) pwr.PowerInterface.state.fset(self, pwr_state) else: bad_state = power_utils.get_power_state_name(pwr_state) msg = "Cannot set power state: " + bad_state raise InvalidOperationException(msg)
def get_cpu_temperature(): """Get the CPU temperature. :returns: The CPU temperature. :rtype: int, long :raises: raspy.invalid_operation_exception.InvalidOperationException if invalid command ("measure_temp") or response. """ # CPU temperature is in the form: # pi@mypi$ /opt/vc/bin/vcgencmd measure_temp # temp=42.3'C # Support for this was added around firmware version 3357xx per info # at http://www.raspberrypi.org/phpBB3/viewtopic.php?p=169909#p169909 result = exec_utils.execute_command("/opt/vc/bin/vcgencmd measure_temp") if result is not None: val = -1 separators = ["\\\[", "\\\=", "\\\]", "\\\'"] # noinspection PyTypeChecker for i, line in enumerate(result): parts = re.split('|'.join(map(re.escape, separators)), line) try: val = float(parts[1]) except ValueError: val = -1 return val raise InvalidOperationException("Invalid command or response.")
def get_cpu_info(target): """Get information about the CPU. Returns the value from the specified target field. :param string target: The target attribute to the value of. :returns: The value of the specified CPU attribute. :rtype: string :raises: raspy.invalid_operation_exception.InvalidOperationException if the specified target is invalid (unknown). """ global __cpuInfo if __cpuInfo is None: __cpuInfo = [] result = exec_utils.execute_command("cat /proc/cpuinfo") if result is not None: # noinspection PyTypeChecker for key, val in enumerate(result): line = val parts = line.split(":") if len(parts) >= 2: tpart0 = string_utils.trim(parts[0]) tpart1 = string_utils.trim(parts[1]) if (not string_utils.is_null_or_empty(tpart0) and not string_utils.is_null_or_empty(tpart1)): # noinspection PyTypeChecker __cpuInfo[tpart0] = tpart1 if target in __cpuInfo: # noinspection PyTypeChecker return __cpuInfo[target] raise InvalidOperationException("Invalid target: " + target)
def pwm(self, val): """Get the PWM (pulse-width modulation) value. :param int val: The PWM value. :raises: raspy.invalid_operation_exception.InvalidOperationException if setting a PWM value on a pin that is not configured as PWM. """ if self.mode == pin_mode.PWM: err_msg = "Cannot set PWM value on a pin not configured for PWM." raise InvalidOperationException(err_msg) if val < 0: val = 0 if val > 1023: val = 1023 if self.__pwm != val: self.__pwm = val if not self.__isPWM: cmd = "gpio mode " + str(self.inner_pin) + " pwm" exec_utils.execute_command(cmd) cmd = "gpio pwm " + str(self.inner_pin) + " " + str(self.__pwm) exec_utils.execute_command(cmd)
def set_timeout_delay(self, delay, unit): """Get the timeout delay. :param int delay: The timeout delay. :param int unit: The time unit of measure for the timeout. :raises: raspy.invalid_operation_exception.InvalidOperationException if the fireplace is turned off. """ if self.is_off: msg = "Cannot set timeout when the fireplace is off." raise InvalidOperationException(msg) self.__timeoutDelay = delay self.__timeoutUnit = unit self.cancel_timeout() if self.__timeoutDelay > 0: wait_time = datetime.timedelta() if unit == time_unit.DAYS: wait_time = datetime.timedelta(days=delay) elif unit == time_unit.HOURS: wait_time = datetime.timedelta(hours=delay) elif unit == time_unit.MINUTES: wait_time = datetime.timedelta(minutes=delay) elif unit == time_unit.SECONDS: wait_time = datetime.timedelta(seconds=delay) elif unit == time_unit.MILLISECONDS: wait_time = datetime.timedelta(milliseconds=delay) kill_delay = datetime.timedelta( milliseconds=wait_time.total_seconds()) kill_delay += datetime.timedelta(seconds=1) sec = kill_delay.total_seconds() self.__killTimer = threading.Timer(sec, self._cancel_timeout_task) self.__killTimer.start() self._start_cancel_task()
def decrease(self, steps=0): """Decrease the wiper's value by the specified number of steps. It is not an error if the wiper hits or already hit the lower boundary (0). In such situations, the wiper sticks to the lower boundary or doesn't change. :param int steps: The number of steps to decrease by. If not specified or zero, then defaults to 1. :raises: raspy.io.io_exception.IOException if communication with the device failed. """ if self.__currentValue == 0: return if steps < 0: msg = "Only positive integer values are permitted." raise IllegalArgumentException(msg) if self.non_volatile_mode != microchip_pot_non_volatile_mode.VOLATILE_ONLY: msg = "Decrease is only permitted on volatile-only wipers." raise InvalidOperationException(msg) # Check bounds: actual_steps = steps if steps > self.__currentValue: actual_steps = self.__currentValue new_val = self.__currentValue - actual_steps if new_val == 0 or steps > 5: self.__currentValue = new_val else: chan = device_control_channel.value_of(self.__channel) self.__controller.decrease(chan, actual_steps) self.__currentValue = new_val
def poll(self): """Start a pin poll cycle. This will monitor the pin and check for state changes. If a state change is detected, the raspy.io.Gpio.EVENT_GPIO_STATE_CHANGED event will be emitted. The poll cycle runs asynchronously until stopped by the cancel_poll() method or when this object instance is disposed. :raises: raspy.object_disposed_exception.ObjectDisposedException if this instance has been disposed. :raises: raspy.invalid_operation_exception.InvalidOperationException if the poll thread is already running. """ if self.is_disposed: raise ObjectDisposedException("PiFaceGpioDigital") if self.__pollRunning: raise InvalidOperationException("Poll thread already running.") self.__stopEvent.clear() self.__pollThread = threading.Thread(target=self.__background_poll) self.__pollThread.name = "PiFaceGpioPoller" self.__pollThread.daemon = True self.__pollThread.start() self.__pollRunning = True
def _validate_row_index(self, row=0): """Validate the index of the specified row. :param int row: The index of the row to validate. :raises: raspy.invalid_operation_exception.InvalidOperationException if the row index is invalid for the display. """ if row >= self.row_count or row < 0: raise InvalidOperationException("Invalid row index.")
def _validate_column_index(self, column=0): """Validate the index of the specified column. :param int column: The index of the column to validate. :raises: raspy.invalid_operation_exception.InvalidOperationException if the column index is invalid for the display. """ if column >= self.column_count or column < 0: raise InvalidOperationException("Invalid column index.")
def _get_non_volatile_value(self): """Get the non-volatile wiper's value. :returns: The non-volatile wiper's value. :rtype: int :raises: raspy.invalid_operation_exception.InvalidOperationException if this device is not capable of non-volatile wipers. """ if self.is_non_volatile_wiper_capable: msg = "This device is not capable of non-volatile wipers." raise InvalidOperationException(msg) chan = device_control_channel.value_of(self.__channel) return self.__controller.get_value(chan, True)
def _set_non_volatile_mode(self, mode): """Set the non-volatility mode. :param int mode: The way non-volatile reads or writes are done. :raises: raspy.invalid_operation_exception.InvalidOperationException if this device is not capable of non-volatile wipers. """ vol_only = microchip_pot_non_volatile_mode.VOLATILE_ONLY if (not self.is_non_volatile_wiper_capable and self.__nonVolMode != vol_only): msg = "This device is not capable of non-volatile wipers." msg += "You *must* use microchip_pot_non_volatile_mode.VOLATILE_ONLY" raise InvalidOperationException(msg) self.__nonVolMode = mode
def write_bytes(self, address, buf): """Write a list of bytes to the specified device address. Currently, RPi drivers do not allow writing more than 3 bytes at a time. As such, if any list of greater than 3 bytes is provided, an exception is thrown. :param int address: The address of the target device. :param list buf: A list of bytes to write to the bus. :raises: raspy.object_disposed_exception.ObjectDisposedException if this instance has been disposed. :raises: raspy.invalid_operation_exception.InvalidOperationException if a connection to the I2C bus has not yet been opened. :raises: raspy.illegal_argument_exception.IllegalArgumentException if the buffer contains more than 3 bytes or if the specified buffer parameter is not a list. :raises: raspy.io.io_exception.IOException if an error occurs while writing the buffer contents to the I2C bus or if only a partial write succeeds. """ if self.is_disposed: raise ObjectDisposedException("I2CBus") if not self.__isOpen: raise InvalidOperationException("No open connection to write to.") if isinstance(buf, list): if len(buf) > 3: # TODO we only do this to keep parity with the JS and C# # ports. They each have their own underlying native # implementations. SMBus2 itself is capable of writing # much more than 3 bytes. We should change this as soon # as we can get the other ports to support more. msg = "Cannot write more than 3 bytes at a time." raise IllegalArgumentException(msg) else: msg = "The specified buf param value is not a list." raise IllegalArgumentException(msg) try: trans = i2c_msg.write(address, buf) self.__bus.i2c_rdwr(trans) except OSError or IOError: msg = "Error writing to address '" + str(address) msg += "': I2C transaction failed." raise IOException(msg)
def turn_off(self): """Turn the light off. :raises: raspy.object_disposed_exception.ObjectDisposedException if this instance has been disposed. """ if self.is_disposed: raise ObjectDisposedException("LedComponent") if self.__pin.mode != pin_mode.OUT: msg = "Pin is not configured as an output pin." raise InvalidOperationException(msg) if self.__pin.state != OFF_STATE: self.__pin.write(pin_state.LOW) evt = LightStateChangeEvent(False) Led.on_light_state_changed(self, evt)
def pulse(self, millis): """Pulse the pin output for the specified number of milliseconds. :param int, long millis: The number of milliseconds to wait between states. :raises: raspy.object_disposed_exception.ObjectDisposedException if this instance has been disposed. """ if self.mode == pin_mode.IN: err_msg = "You cannot pulse a pin set as an input" raise InvalidOperationException(err_msg) pin_addr = self.inner_pin.value self.__write(self.inner_pin, pin_state.HIGH) evt = PinStateChangeEvent(self.state, pin_state.HIGH, pin_addr) self.on_pin_state_change(evt) gpio.Gpio.pulse(self, millis) self.__write(self.inner_pin, pin_state.LOW) evt = PinStateChangeEvent(self.state, pin_state.LOW, pin_addr) self.on_pin_state_change(evt)
def get_os_firmware_date(): """Get the OS firmware date. :returns: The OS firmware date. :rtype: string :raises: raspy.invalid_operation_exception.InvalidOperationException if an unexpected response is received. """ results = exec_utils.execute_command("/opt/vc/bin/vcgencmd version") val = string_utils.EMPTY if results is not None: # noinspection PyTypeChecker for key, value in enumerate(results): # We are intentionally only getting the first line. val = value break if not string_utils.is_null_or_empty(val): return val raise InvalidOperationException("Invalid command or response.")
def poll(self): """Poll the input pin status every 500ms until stopped. :raises: raspy.object_disposed_exception.ObjectDisposedException if this instance has been disposed. :raises: raspy.invalid_operation_exception.InvalidOperationException if the underlying pin is not an input pin. """ if self.is_disposed: raise ObjectDisposedException("MotionSensorComponent") if self.pin.mode != pin_mode.IN: msg = "The specified pin is not configured as an input pin, which" msg += " is required to read sensor data." raise InvalidOperationException(msg) self.__stopEvent.clear() self.__isPolling = True self.__pollThread = threading.Thread(target=self._execute_poll) self.__pollThread.name = "MotionSensorComponentPollThread" self.__pollThread.daemon = True self.__pollThread.start()
def get_os_firmware_build(): """Get the OS firmware build. :returns: the OS firmware build. :rtype: string :raises: raspy.invalid_operation_exception.InvalidOperationException if an unexpected response is received. """ results = exec_utils.execute_command("/opt/vc/bin/vcgencmd version") val = string_utils.EMPTY if results is not None: # noinspection PyTypeChecker for key, val in enumerate(results): line = val if string_utils.starts_with(line, "version "): val = line break if not string_utils.is_null_or_empty(val): return val[8:] raise InvalidOperationException("Invalid command or response")
def increase(self, steps=0): """Increase the wiper's value bye the specified number of steps. It is not an error if the wiper hits or already hit the upper boundary. In such situations, the wiper sticks to the upper boundary or doesn't change. :param int steps: How many steps to increase. If not specified or zero, then defaults to 1. If the current value is equal to the max value, then nothing happens. If steps is less than zero, then an exception is thrown. :raises: raspy.io.io_exception.IOException if communication with the device failed. """ max_val = self.max_value if self.__currentValue == max_val: return if steps < 0: msg = "Only positive integer values are permitted." raise IllegalArgumentException(msg) vol_only = microchip_pot_non_volatile_mode.VOLATILE_ONLY if self.non_volatile_mode != vol_only: msg = "Increase is only permitted for volatile-only wipers." raise InvalidOperationException(msg) # Check bounds. actual_steps = steps if (steps + self.__currentValue) > max_val: actual_steps = max_val - self.__currentValue new_val = self.__currentValue + actual_steps if new_val == max_val or steps > 5: self.__currentValue = new_val else: chan = device_control_channel.value_of(self.__channel) self.__controller.increase(chan, actual_steps) self.__currentValue = new_val
def poll(self): """Start a button state poll cycle. This will monitor the button state in a poll loop on a separate thread and fire events when the button state changes. :raises: raspy.object_disposed_exception.ObjectDisposedException if this instance has been disposed. :raises: raspy.invalid_operation_exception.InvalidOperationException if the poll thread is already running. """ if self.is_disposed: raise ObjectDisposedException("ButtonComponent") if self.__pollRunning: raise InvalidOperationException("Poll thread already running.") self.__stopEvent.clear() self.__pollRunning = True self.__pollThread = threading.Thread(target=self._execute_poll) self.__pollThread.name = "ButtonComponentPollThread" self.__pollThread.daemon = True self.__pollThread.start()
def read_bytes(self, address, count): """Read bytes from the device at the specified address. :param int address: The address of the device to read from. :param int count: The number of bytes to read. :returns: The bytes read. :rtype: list :raises: raspy.object_disposed_exception.ObjectDisposedException if this instance has been disposed. :raises: raspy.invalid_operation_exception.InvalidOperationException if a connection to the I2C bus has not yet been opened. :raises: raspy.io.io_exception.IOException if an error occurs while writing the buffer contents to the I2C bus or if only a partial write succeeds. """ if self.is_disposed: return if not self.__isOpen: raise InvalidOperationException("No open connection to read from.") buf = [] msg = "Error reading from address '" + str(address) msg += "': I2C transaction failed." try: trans = i2c_msg.read(address, count) self.__bus.i2c_rdwr(trans) buf = list(trans) except OSError or IOError: raise IOException(msg) if len(buf) <= 0: raise IOException(msg) return buf
def poll(self): """Poll the switch status. :raises: ObjectDisposedException if this instance has been disposed. :raises: InvalidOperationException if this switch is attached to a pin that has not been configured as an input. """ if self.is_disposed: raise ObjectDisposedException("SwitchComponent") if self.__pin.mode != pin_mode.IN: msg = "The pin this switch is attached to must be configured" msg += " as an input." raise InvalidOperationException(msg) if self.__isPolling: return self.__stopEvent.clear() self.__isPolling = True self.__pollThread = threading.Thread(target=self._execute_poll) self.__pollThread.name = "MomentarySwitchComponentPollThread" self.__pollThread.daemon = True self.__pollThread.start()