def check_range(from_index, to_index): """Check to see if the specified indexes are in range. :param int from_index: The starting index. :param int to_index: The ending index. :raises: ArgumentNullException if either param is None. :raises: IllegalArgumentException if either param is not an int. :raises: IndexError if either param is less than zero. """ if from_index is None: raise ArgumentNullException("from_index cannot be None.") if to_index is None: raise ArgumentNullException("to_index cannot be None.") if not isinstance(from_index, int): raise IllegalArgumentException("from_index MUST be an int.") if not isinstance(to_index, int): raise IllegalArgumentException("to_index MUST be an int.") if from_index < 0: raise IndexError("from_index cannot be less than zero.") if to_index < 0: raise IndexError("to_index cannot be less than zero.") if from_index > to_index: raise IndexError("from_index cannot be greater than to_index.")
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 get_terminal_config(self, channel=None): """Get the terminal configuration for the specified channel. :param DeviceControlChannel channel: The channel to get the terminal configuration for. :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.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) # Read the current config. tcon = self._read(channel.term_control_address) # Build result chan_enabled = (tcon & channel.hardware_config_ctrl_bit) > 0 pin_a_enabled = (tcon & channel.term_a_connection_ctrl_bit) > 0 pin_w_enabled = (tcon & channel.wiper_connection_ctrl_bit) > 0 pin_b_enabled = (tcon & channel.term_b_connection_ctrl_bit) > 0 return DeviceControllerTermConfig(channel, chan_enabled, pin_a_enabled, pin_w_enabled, pin_b_enabled)
def bs_and(self, b_set): """Perform a logical AND of this BitSet with the specified BitSet. This BitSet is modified so that each bit in it has the value True if (and only if) it both initially had the value True and the corresponding bit in the specified BitSet also had the value True. :param BitSet b_set: A BitSet. Raises ArgumentNullException if None. :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 self == b_set: return if not isinstance(b_set, BitSet): raise IllegalArgumentException("param 'b_set' must be a BitSet.") while self.__words_in_use > b_set.get_words_in_use(): self.__words_in_use -= 1 self.__bits[self.__words_in_use] = 0 for i in range(0, self.__words_in_use - 1): self.__bits[i] &= b_set.get_bits()[i] self.recalculate_words_in_use() self._check_invariants()
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 increase(self, channel=None, steps=0): """Increment the volatile wiper for the given number of steps. :param DeviceControlChannel channel: The device channel the wiper is on. :param int steps: The number of steps. :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) # Increase only works on volatile-wiper. if steps is None: steps = 0 mem_addr = channel.volatile_mem_address self._increase_or_decrease(mem_addr, True, steps)
def __init__(self, mag, deg_per_sec_factor=None): """Initialize a new instance of AxisGyroscope. :param raspy.components.gyroscopes.mutli_axis_gyro.MultiAxisGyro mag: The multi-axis gyro to read from. :param float deg_per_sec_factor: The degrees-per-second factor value. """ Gyro.__init__(self) if mag is None: raise ArgumentNullException("'mag' param cannot be None.") if not isinstance(mag, MultiAxisGyro): msg = "'mag' param must be an instance of " msg += "raspy.components.gyroscopes.multi_axis_gyro.MultiAxisGyro." raise IllegalArgumentException(msg) self.__multiAxisGyro = mag self.__trigger = gyro_trigger_mode.READ_NOT_TRIGGERED self.__value = 0.0 self.__offset = 0.0 self.__angle = 0.0 self.__degPerSecondFactor = 0 self.__factorSet = False if deg_per_sec_factor: if isinstance(deg_per_sec_factor, float): self.__degPerSecondFactor = deg_per_sec_factor self.__factorSet = True
def pad_center(data, char, length): """Pad the center of the specified string. Adds the specified padding character(s) to the center of the specified string. :param str data: The string to pad. :param str char: The character or string to pad the center of the specified string with. If null or empty string, DEFAULT_PAD_CHAR will be used instead. :param int length: The number of characters or instances of string to pad the center with. :returns: The padded version of the string. :rtype: str :raises raspy.illegal_argument_exception.IllegalArgumentException: if data param is null or not a string. """ if is_null_or_empty(data): raise IllegalArgumentException("data param must be a string.") if is_null_or_empty(char): char = DEFAULT_PAD_CHAR if len(data) > 2 and length > 0: first_half = data[:len(data) / 2] second_half = data[len(data) / 2:len(data)] padding_char = create(char, length) string_buf = first_half + padding_char + second_half return string_buf return data
def __init__(self, provider): """Initialize a new instance of raspy.lcd.lcd_module.LcdModule class. :param raspy.lcd.lcd_transfer_provider.LcdTransferProvider provider: The transfer provider to use to send data and commands to the display. :raises: raspy.illegal_argument_exception.IllegalArgumentException if the provider is None or not an instance of LcdTransferProvider. """ super(Disposable, self).__init__() if provider is None or not isinstance(provider, LcdTransferProvider): msg = "'provider' param bust be an LcdTransferProvider" raise IllegalArgumentException(msg) self.__rowOffsets = [0x00, 0x40, 0x14, 0x54] self.__showCursor = True self.__blinkCursor = True self.__visible = True self.__backlight = True self.__numLines = 0 self.__numColumns = 0 self.__sendQueue = list() self.__ready = False # self.__autoScroll = False # TODO implement this? # self._currLine = 0 # TODO implement this? self.__provider = provider if self.__provider.is_four_bit_mode: self.__displayFunction = (function_set_flags.FOUR_BIT_MODE | function_set_flags.ONE_LINE | function_set_flags.FIVE_BY_EIGHT_DOTS) else: self.__displayFunction = (function_set_flags.EIGHT_BIT_MODE | function_set_flags.ONE_LINE | function_set_flags.FIVE_BY_EIGHT_DOTS)
def __init__(self, bits): """Initialize a new instance of BitSet. :param int, list bits: The initial size of the BitSet -or- a list of words bits (words) to compose this instance from. :raises: IllegalArgumentException if 'bits' param is not a valid type (must be an int or a list of bits). :raises: IndexError if 'bits' is an int but is less than zero. """ self.__bits = list() self.__words_in_use = 0 self.__size_is_sticky = False self.name = "BitSet" # Main constructor logic. if bits is None: self.__bits = [None] * BITS_PER_WORD else: if isinstance(bits, int): if bits < 0: raise IndexError("'bits' param must not be negative.") self.__bits = [None] * word_index(bits - 1) + 1 self.__size_is_sticky = True elif isinstance(bits, list): self.__bits = bits self.__words_in_use = len(self.__bits) self._check_invariants() else: raise IllegalArgumentException( "param 'bits' must be an int or a list")
def bs_or(self, b_set): """Perform a logical OR of this BitSet with the specified BitSet. This BitSet is modified so that a bit in it has the value True if (and only if) it either already had the value True or 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 self == b_set: return if not isinstance(b_set, BitSet): raise IllegalArgumentException("param 'b_set' must be a 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() for i in range(0, words_in_common - 1): self.__bits[i] |= b_set.get_bits()[i] if words_in_common < b_set.get_words_in_use(): self.__bits = self.__bits[0:self.__words_in_use - words_in_common] self._check_invariants()
def set_value(self, channel=None, value=0, non_vol=False): """Set the wiper's value in the device. :param DeviceControlChannel channel: The device channel the wiper is on. :param int value: The wiper's value. :param bool non_vol: Set True to write to non-volatile memory, or False to write to volatile memory. :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 - or - if 'value' param is a negative number. :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) if value < 0: msg = "Only positive integer values are permitted. Got value: '" msg += str(value) + "' for writing to channel '" msg += channel.name 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 # Write value to device. self._write(mem_addr, value)
def output_file(self, out_file): """Set the output file the image will be captured to. :param FileInfo out_file: The output file. :raises: IllegalArgumentException if out_file is not of type FileInfo. """ if type(out_file) != FileInfo: msg = "out_file must be of type raspy.io.file_info.FileInfo" raise IllegalArgumentException(msg) self.__outputFile = out_file
def image_quality(self, quality): """Set the image quality. :param int quality: The image quality level. :raises: IllegalArgumentException if the quality level is not a value between QUALITY_MIN and QUALITY_MAX. """ if quality < QUALITY_MIN or quality > QUALITY_MAX: msg = "Quality value out of range." raise IllegalArgumentException(msg) self.__quality = quality
def image_size(self, img_size): """Set the size of the image. :param raspy.size.Size img_size: The image size. :raises: IllegalArgumentException if img_size is not of type `raspy.size.Size`. """ if type(img_size) != size.Size: msg = "img_size property must be of type raspy.size.Size" raise IllegalArgumentException(msg) self.__size = img_size
def set_bit_raw_value(self, index, bit): """Set the raw bit value at the specified index. Avoid using this method whenever possible. Instead, use either set() or set_from_to() so as to preserve invariants. :param int index: The index at which to set the specified bit. :param int, bool bit: Set True or 1 to set the bit, or False or 0 to clear the bit. :raises: IllegalArgumentException if index is not an int -or- bit parameter is not an int or a bool. :raises: IndexError if index parameter is less than zero. """ if not isinstance(index, int): raise IllegalArgumentException("index must be a valid integer.") if index < 0 or index > len(self.__bits) - 1: msg = "index must be greater than zero and less than or " msg += "equal to the last index in the bit set." raise IndexError(msg) if isinstance(bit, int): if bit < 0: bit = 0 if bit > 1: bit = 1 elif isinstance(bit, bool): if bit: bit = 1 else: bit = 0 else: msg = "bit must be a number (0 or 1) or bool." raise IllegalArgumentException(msg) self.__bits[index] = bit
def __init__(self, device=None, pin_a0=False, pin_a1=False, pin_a2=False, channel=microchip_pot_channel.NONE, non_vol_mode=microchip_pot_non_volatile_mode. VOLATILE_AND_NON_VOLATILE, init_non_vol_wiper_val=0): """Initialize a new instance of MicrochipPotentiometer. :param raspy.io.i2c.i2c_interface.I2CInterface device: The I2C bus device this instance is connected to. :param bool pin_a0: Set True if device's address pin A0 is high. :param bool pin_a1: Set True if device's address pin A1 is high. :param bool pin_a2: Set True if device's address pin A2 is high. :param int channel: The potentiometer channel. :param int non_vol_mode: The non-volatility mode. :param int init_non_vol_wiper_val: The initial value to set. :raises: raspy.argument_null_exception.ArgumentNullException if 'device' param is None. :raises: raspy.illegal_argument_exception.IllegalArgumentException if the specified channel is not supported by the device. :raises: raspy.io.io_exception.IOException if unable to open the I2C bus. """ Potentiometer.__init__(self) if device is None: msg = "Param 'device' cannot be None." raise ArgumentNullException(msg) if not self.is_channel_supported(channel): msg = "Specified channel not supported by device." raise IllegalArgumentException(msg) self.__emitter = EventEmitter() self.__channel = channel self.__currentValue = 0 self.__nonVolMode = non_vol_mode device_addr = MicrochipPotentiometer._build_i2c_address( pin_a0, pin_a1, pin_a2) self.__controller = mcp_device_controller.MCPDeviceController( device, device_addr) self.__emitter.on( EVENT_WIPER_ACTION, lambda wiper_evt: self._on_wiper_action_event(wiper_evt)) self._initialize(init_non_vol_wiper_val)
def set(self, index): """Set the bit at the specified index True. :param int index: The index at which to set the bit. :raises: IllegalArgumentException if index is not an int. :raises: IndexError if index is less than zero. """ if not isinstance(index, int): raise IllegalArgumentException("index must be a valid integer.") if index < 0: raise IndexError("index cannot be less than zero.") offset = word_index(index) self._expand_to(offset) self.__bits[offset] |= (1 << index) # Restore invariants. self._check_invariants()
def set_terminal_config(self, config=None): """Set the device's terminal configuration. :param DeviceControllerTermConfig config: The configuration to set. :raises: raspy.object_disposed_exception.ObjectDisposedException if this instance has been disposed. :raises: raspy.argument_null_exception.ArgumentNullException if the 'config' param is None. :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 config is None: raise ArgumentNullException("'config' param cannot be None.") if not isinstance(config, DeviceControllerTermConfig): msg = "'config' param must be of type DeviceControllerTermConfig." raise IllegalArgumentException(msg) chan = config.channel if chan is None: msg = "A configuration with a null channel is not permitted." raise ArgumentNullException(msg) # Read current config. mem_addr = config.channel.term_control_address tcon = self._read(mem_addr) # Modify config. ctrl_bit = chan.hardware_config_ctrl_bit tcon = self._set_bit(tcon, ctrl_bit, config.channel_enabled) ctrl_bit = chan.term_a_connection_ctrl_bit tcon = self._set_bit(tcon, ctrl_bit, config.pin_a_enabled) ctrl_bit = chan.wiper_connection_ctrl_bit tcon = self._set_bit(tcon, ctrl_bit, config.pin_w_enabled) ctrl_bit = chan.term_b_connection_ctrl_bit tcon = self._set_bit(tcon, ctrl_bit, config.pin_b_enabled) # Write new config to device. self._write(mem_addr, tcon)
def flip(self, index): """Set the bit at the specified index to the compliment of the value. :param int index: The index of the bit to flip. :raises: IllegalArgumentException if index is not an int. :raises: IndexError if index is less than zero. """ if not isinstance(index, int): raise IllegalArgumentException("index must be a valid integer.") if index < 0: raise IndexError("index cannot be less than zero.") offset = word_index(index) self._expand_to(offset) self.__bits[offset] ^= 1 << index self.recalculate_words_in_use() self._check_invariants()
def get(self, index): """Get the value of the bit at the specified index. :param int index: The index at which to get the bit value. :returns: True if the requested bit is set. :rtype: bool :raises: IllegalArgumentException if index is not an int. :raises: IndexError if index is less than zero. """ if isinstance(index, int): raise IllegalArgumentException("index must be a valied int.") if index < 0: raise IndexError("index cannot be less than zero.") self._check_invariants() offset = word_index(index) return (offset < self.__words_in_use and (self.__bits[index] & (1 << index)) != 0)
def number_of_trailing_zeros(num): """Get the number or trailing zeros in the specified number. :param int num: The number value to inspect. :returns: The number of trailing zeros. :rtype: int :raises: IllegalArgumentException if the 'num' param is not a number. """ if num is None: return 0 if not isinstance(num, int): raise IllegalArgumentException("param 'num' must be an int.") mask = 1 result = 64 for i in range(0, 63): mask <<= 1 if (num & mask) != 0: result = i break return result
def __init__(self, dcc=None, chan_enabled=False, pin_a_enabled=False, pin_w_enabled=False, pin_b_enabled=False): """Initialize a new instance of DeviceControllerTermConfig. :param device_control_channel.DeviceControlChannel dcc: The device control channel. :param bool chan_enabled: Set True to enable the channel. :param bool pin_a_enabled: Set True to enable pin A. :param bool pin_w_enabled: Set True to enable pin W. :param bool pin_b_enabled: Set True to enable pin B. :raises: raspy.illegal_argument_exception.IllegalArgumentException if param dcc is not an instance of DeviceControlChannel. """ instance = isinstance(dcc, device_control_channel.DeviceControlChannel) if dcc is not None and not instance: msg = "'dcc' param must be object of type DeviceControlChannel" raise IllegalArgumentException(msg) self.__channel = dcc self.__channelEnabled = chan_enabled self.__pinAEnabled = pin_a_enabled self.__pinWEnabled = pin_w_enabled self.__pinBEnabled = pin_b_enabled
def value_of(words): """Get a new BitSet containing all the bits in the specified list. :param list words: The list of bits to construct a BitSet from. If None, then this function will return None. :returns: A new BitSet containing the specified list of bits. :rtype: BitSet :raises: IllegalArgumentException if not a list. """ if words is None: return None if not isinstance(words, list): raise IllegalArgumentException( "param 'words' must be an array of bits.") num = len(words) while num > 0 and words[num - 1] == 0: num -= 1 words_copy = list(words) return BitSet(words_copy)
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 __init__(self, provider, rows=0, columns=0): """Initialize a new instance of LcdComponent. :param raspy.lcd.lcd_transfer_provider.LcdTransferProvider provider: The LCD transfer provider. :param int rows: The number of rows in the display. :param int columns: The number of columns in the display. :raises: raspy.argument_null_exception.ArgumentNullException if the provider is None. :raises: raspy.illegal_argument_exception.IllegalArgumentException if the specified provider is not of LcdTransferProvider type. """ Lcd.__init__(self) if provider is None: raise ArgumentNullException("'provider' cannot be None.") if not isinstance(provider, LcdTransferProvider): msg = "'provider' must be of type LcdTransferProvider " msg += "or derivative." raise IllegalArgumentException(msg) self.__module = LcdModule(provider) self.__module.begin(columns, rows)
def __init__(self, device, bus_address=-1): """Initialize a new instance of MCPDeviceController. :param raspy.io.i2c.i2c_interface.I2CInterface device: The I2C bus device this instance is connected to. :param int bus_address: The bus address of the device. :raises: raspy.argument_null_exception.ArgumentNullException if param 'device' is None. :raises: raspy.illegal_argument_exception.IllegalArgumentException if param 'device' is not of type I2CInterface. """ Disposable.__init__(self) if device is None: raise ArgumentNullException("Param 'device' cannot be None.") if not isinstance(device, I2CInterface): msg = "Param 'device' must be of I2CInterface." raise IllegalArgumentException(msg) self.__busAddress = bus_address self.__device = device if not self.__device.is_open: self.__device.open()
def and_not(self, b_set): """Clear all bits in this BitSet matching bits in specified BitSet. This clears all of the bits in this BitSet whose corresponding bit is set in the specified BitSet. :param BitSet b_set: The BitSet with which to mask this instance. :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.") i = min(len(self.__bits), len(b_set.get_bits())) while i >= 0: i -= 1 self.__bits[i] &= ~b_set.get_bits()[i] self.recalculate_words_in_use() self._check_invariants()
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)