def x_or(self, b_set): """Perform a logical XOR of this BitSet with the specified BitSet. This BitSet is modified so that the bits in it have the value True if (and only if) one of the following statements hold true: - The bit initially has the value True, and the corresponding bit in the specified BitSet has the value False. - The bit initially has the value False, and the corresponding bit in the specified BitSet has the value True. :param BitSet b_set: A BitSet. :raises: ArgumentNullException if bs is None. :raises: IllegalArgumentException if bs is not a BitSet. """ if b_set is None: raise ArgumentNullException("param 'b_set' cannot be None.") if not isinstance(b_set, BitSet): raise IllegalArgumentException("param 'b_set' must be a BitSet.") # Calculate how many words which have in common with the other BitSet. words_in_common = min(self.__words_in_use, b_set.get_words_in_use()) if self.__words_in_use < b_set.get_words_in_use(): self._ensure_capacity(b_set.get_words_in_use()) self.__words_in_use = b_set.get_words_in_use() # Perform logical XOR on words in common. for i in range(0, words_in_common - 1): self.__bits[i] ^= b_set.get_bits()[i] # Copy any remaining words. if words_in_common < b_set.get_words_in_use(): self.__bits = self.__bits[0:b_set.get_words_in_use() - words_in_common] self.recalculate_words_in_use() self._check_invariants()
def terminal_configuration(self, config): """Set the terminal configuration. :param MCPTerminalConfiguration config: The terminal configuration. :raises: raspy.io.io_exception.IOException if communication with the device fails. """ if config is None: raise ArgumentNullException("config value cannot be None.") if config.channel != self.__channel: msg = "Setting a configuration with a channel that is not the " msg += "potentiometer's channel is not supported." raise IllegalArgumentException(msg) chan = device_control_channel.value_of(self.__channel) chan_enable = config.is_channel_enabled pin_a = config.is_pin_a_enabled pin_w = config.is_pin_w_enabled pin_b = config.is_pin_b_enabled dev_con = DeviceControllerTermConfig(chan, chan_enable, pin_a, pin_w, pin_b) self.__controller.set_terminal_config(dev_con)
def get_value(self, channel=None, non_vol=False): """Receive the current wiper's value from the device. :param DeviceControlChannel channel: The device channel the wiper is on. :param bool non_vol: Set True to read from non-volatile memory, or False to read from volatile memory. :returns: The wiper's value. :rtype: int :raises: raspy.object_disposed_exception.ObjectDisposedException if this instance has been disposed. :raises: raspy.argument_null_exception.ArgumentNullException if the 'channel' param is None. :raises: raspy.illegal_argument_exception.IllegalArgumentException if param 'channel' is not of type DeviceControlChannel. :raises: raspy.io.io_exception.IOException if an I/O error occurred. The specified address is inaccessible or the I2C transaction failed. """ if self.is_disposed: return ObjectDisposedException("MCPDeviceController") if channel is None: raise ArgumentNullException("'channel' param cannot be None.") if not isinstance(channel, device_control_channel.DeviceControlChannel): msg = "'channel' param must be of type DeviceControlChannel." raise IllegalArgumentException(msg) # Choose proper mem address. if non_vol is None: non_vol = False mem_addr = channel.volatile_mem_address if non_vol: mem_addr = channel.non_volatile_mem_address return self._read(mem_addr)
def __init__(self, pn, initial_val, name): """Initialize a new instance of the raspy.io.PiFaceGPIO class. :param raspy.io.pi_face_pin.PiFacePin pn: The underlying PiFace pin. :param int initial_val: The initial pin value (state). :param string name: The pin name. :raises: raspy.argument_null_exception.ArgumentNullException if the specified pin is NonePin. :raises: raspy.illegal_argument_exception.IllegalArgumentException if the specified pin is not of type raspy.io.pi_face_pins.PiFacePin. """ gpio.Gpio.__init__(self, pn, pin_mode.IN, initial_val) self.__pwm = 0 self.__pwmRange = 0 if pn is None: raise ArgumentNullException("pn param cannot be NonePin.") if not isinstance(pn, pi_face_pins.PiFacePin): err_msg = "pn param must be a PiFacePins member." raise IllegalArgumentException(err_msg) self.pin_name = name if string_utils.is_null_or_empty(self.pin_name): self.pin_name = pn.name if (pn == pi_face_pins.Input00 or pn == pi_face_pins.Input01 or pn == pi_face_pins.Input02 or pn == pi_face_pins.Input03 or pn == pi_face_pins.Input04 or pn == pi_face_pins.Input05 or pn == pi_face_pins.Input06 or pn == pi_face_pins.Input07): self.mode = pin_mode.IN elif (pn == pi_face_pins.Output00 or pn == pi_face_pins.Output01 or pn == pi_face_pins.Output02 or pn == pi_face_pins.Output03 or pn == pi_face_pins.Output04 or pn == pi_face_pins.Output05 or pn == pi_face_pins.Output06 or pn == pi_face_pins.Output07): self.mode = pin_mode.OUT
def set_wiper_lock(self, channel=None, locked=False): """Enable or disable the wiper's lock. :param device_control_channel.DeviceControlChannel channel: The channel of the wiper to set the lock for. :param bool locked: Set True to enable the lock or False to disable. :raises: raspy.object_disposed_exception.ObjectDisposedException if this instance has been disposed. :raises: raspy.argument_null_exception.ArgumentNullException if channel is None. """ if self.is_disposed: raise ObjectDisposedException("MCPDeviceController") if channel is None: raise ArgumentNullException("channel param cannot be None.") # Increasing or decreasing on non-volatile wipers enables or # disables the wiper lock. mem_addr = channel.non_volatile_mem_address flag = False if locked is not None: flag = locked self._increase_or_decrease(mem_addr, flag, 1)