我们从Python开源项目中，提取了以下26个代码示例，用于说明如何使用array.ArrayType()。
def aa_i2c_write (aardvark, slave_addr, flags, data_out): """usage: int return = aa_i2c_write(Aardvark aardvark, u16 slave_addr, AardvarkI2cFlags flags, u08[] data_out) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # data_out pre-processing (data_out, num_bytes) = isinstance(data_out, ArrayType) and (data_out, len(data_out)) or (data_out[0], min(len(data_out[0]), int(data_out[1]))) if data_out.typecode != 'B': raise TypeError("type for 'data_out' must be array('B')") # Call API function return api.py_aa_i2c_write(aardvark, slave_addr, flags, num_bytes, data_out) # Write a stream of bytes to the I2C slave device. # This API function returns the number of bytes written into # the num_written variable. The return value of the function # is a status code.
def aa_i2c_slave_set_response (aardvark, data_out): """usage: int return = aa_i2c_slave_set_response(Aardvark aardvark, u08[] data_out) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # data_out pre-processing (data_out, num_bytes) = isinstance(data_out, ArrayType) and (data_out, len(data_out)) or (data_out[0], min(len(data_out[0]), int(data_out[1]))) if data_out.typecode != 'B': raise TypeError("type for 'data_out' must be array('B')") # Call API function return api.py_aa_i2c_slave_set_response(aardvark, num_bytes, data_out) # Return number of bytes written from a previous # Aardvark->I2C_master transmission. Since the transmission is # happening asynchronously with respect to the PC host # software, there could be responses queued up from many # previous write transactions.
def aa_spi_slave_set_response (aardvark, data_out): """usage: int return = aa_spi_slave_set_response(Aardvark aardvark, u08[] data_out) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # data_out pre-processing (data_out, num_bytes) = isinstance(data_out, ArrayType) and (data_out, len(data_out)) or (data_out[0], min(len(data_out[0]), int(data_out[1]))) if data_out.typecode != 'B': raise TypeError("type for 'data_out' must be array('B')") # Call API function return api.py_aa_spi_slave_set_response(aardvark, num_bytes, data_out) # Read the bytes from an SPI slave reception
def test_reads(circuit_pair, data_type, data_count, data, metadata): cli_circuit, srv_circuit = circuit_pair cli_channel, srv_channel = make_channels(*circuit_pair, data_type, data_count) req = ca.ReadNotifyRequest(data_count=data_count, data_type=data_type, ioid=0, sid=0) buffers_to_send = cli_circuit.send(req) # Socket transport would happen here. Calling bytes() simulates # serialization over the socket. commands, _ = srv_circuit.recv(*(_np_hack(buf) for buf in buffers_to_send)) for command in commands: srv_circuit.process_command(command) res = ca.ReadNotifyResponse(data=data, metadata=metadata, data_count=data_count, data_type=data_type, ioid=0, status=1) buffers_to_send = srv_circuit.send(res) # Socket transport would happen here. Calling bytes() simulates # serialization over the socket. commands, _ = cli_circuit.recv(*(_np_hack(buf) for buf in buffers_to_send)) res_received, = commands cli_circuit.process_command(res_received) if isinstance(data, array.ArrayType): # Before comparing array.array (which exposes the byteorder naively) # with a numpy.ndarray (which buries the byteorder in dtype), flip # the byte order to little-endian. expected = copy.deepcopy(data) expected.byteswap() assert_array_almost_equal(res_received.data, expected) elif isinstance(data, bytes): assert data == _np_hack(res_received.data) else: try: assert_array_equal(res_received.data, data) # for strings except AssertionError: assert_array_almost_equal(res_received.data, data) # for floats
def test_writes(circuit_pair, data_type, data_count, data, metadata): cli_circuit, srv_circuit = circuit_pair cli_channel, srv_channel = make_channels(*circuit_pair, 5, 1) req = ca.WriteNotifyRequest(data=data, metadata=metadata, data_count=data_count, data_type=data_type, ioid=0, sid=0) buffers_to_send = cli_circuit.send(req) # Socket transport would happen here. Calling bytes() simulates # serialization over the socket. commands, _ = srv_circuit.recv(*(_np_hack(buf) for buf in buffers_to_send)) for command in commands: srv_circuit.process_command(command) req_received, = commands res = ca.WriteNotifyResponse(data_count=data_count, data_type=data_type, ioid=0, status=1) buffers_to_send = srv_circuit.send(res) # Socket transport would happen here. Calling bytes() simulates # serialization over the socket. commands, _ = cli_circuit.recv(*(_np_hack(buf) for buf in buffers_to_send)) for command in commands: cli_circuit.process_command(command) if isinstance(data, array.ArrayType): # Before comparing array.array (which exposes the byteorder naively) # with a numpy.ndarray (which buries the byteorder in dtype), flip # the byte order to little-endian. expected = copy.deepcopy(data) expected.byteswap() assert_array_almost_equal(req_received.data, expected) elif isinstance(data, bytes): assert data == _np_hack(req_received.data) else: try: assert_array_equal(req_received.data, data) # for strings except AssertionError: assert_array_almost_equal(req_received.data, data) # for floats
def aa_find_devices (devices): """usage: (int return, u16[] devices) = aa_find_devices(u16[] devices) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function. Additionally, for arrays that are filled by the API function, an integer can be passed in place of the array argument and the API will automatically create an array of that length. All output arrays, whether passed in or generated, are passed back in the returned tuple.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # devices pre-processing __devices = isinstance(devices, int) if __devices: (devices, num_devices) = (array_u16(devices), devices) else: (devices, num_devices) = isinstance(devices, ArrayType) and (devices, len(devices)) or (devices[0], min(len(devices[0]), int(devices[1]))) if devices.typecode != 'H': raise TypeError("type for 'devices' must be array('H')") # Call API function (_ret_) = api.py_aa_find_devices(num_devices, devices) # devices post-processing if __devices: del devices[max(0, min(_ret_, len(devices))):] return (_ret_, devices) # Get a list of ports to which Aardvark devices are attached. # # This function is the same as aa_find_devices() except that # it returns the unique IDs of each Aardvark device. The IDs # are guaranteed to be non-zero if valid. # # The IDs are the unsigned integer representation of the 10-digit # serial numbers.
def aa_i2c_read (aardvark, slave_addr, flags, data_in): """usage: (int return, u08[] data_in) = aa_i2c_read(Aardvark aardvark, u16 slave_addr, AardvarkI2cFlags flags, u08[] data_in) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function. Additionally, for arrays that are filled by the API function, an integer can be passed in place of the array argument and the API will automatically create an array of that length. All output arrays, whether passed in or generated, are passed back in the returned tuple.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # data_in pre-processing __data_in = isinstance(data_in, int) if __data_in: (data_in, num_bytes) = (array_u08(data_in), data_in) else: (data_in, num_bytes) = isinstance(data_in, ArrayType) and (data_in, len(data_in)) or (data_in[0], min(len(data_in[0]), int(data_in[1]))) if data_in.typecode != 'B': raise TypeError("type for 'data_in' must be array('B')") # Call API function (_ret_) = api.py_aa_i2c_read(aardvark, slave_addr, flags, num_bytes, data_in) # data_in post-processing if __data_in: del data_in[max(0, min(_ret_, len(data_in))):] return (_ret_, data_in) # enum AardvarkI2cStatus
def aa_i2c_read_ext (aardvark, slave_addr, flags, data_in): """usage: (int return, u08[] data_in, u16 num_read) = aa_i2c_read_ext(Aardvark aardvark, u16 slave_addr, AardvarkI2cFlags flags, u08[] data_in) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function. Additionally, for arrays that are filled by the API function, an integer can be passed in place of the array argument and the API will automatically create an array of that length. All output arrays, whether passed in or generated, are passed back in the returned tuple.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # data_in pre-processing __data_in = isinstance(data_in, int) if __data_in: (data_in, num_bytes) = (array_u08(data_in), data_in) else: (data_in, num_bytes) = isinstance(data_in, ArrayType) and (data_in, len(data_in)) or (data_in[0], min(len(data_in[0]), int(data_in[1]))) if data_in.typecode != 'B': raise TypeError("type for 'data_in' must be array('B')") # Call API function (_ret_, num_read) = api.py_aa_i2c_read_ext(aardvark, slave_addr, flags, num_bytes, data_in) # data_in post-processing if __data_in: del data_in[max(0, min(num_read, len(data_in))):] return (_ret_, data_in, num_read) # Write a stream of bytes to the I2C slave device.
def aa_i2c_write_read (aardvark, slave_addr, flags, out_data, in_data): """usage: (int return, u16 num_written, u08[] in_data, u16 num_read) = aa_i2c_write_read(Aardvark aardvark, u16 slave_addr, AardvarkI2cFlags flags, u08[] out_data, u08[] in_data) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function. Additionally, for arrays that are filled by the API function, an integer can be passed in place of the array argument and the API will automatically create an array of that length. All output arrays, whether passed in or generated, are passed back in the returned tuple.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # out_data pre-processing (out_data, out_num_bytes) = isinstance(out_data, ArrayType) and (out_data, len(out_data)) or (out_data[0], min(len(out_data[0]), int(out_data[1]))) if out_data.typecode != 'B': raise TypeError("type for 'out_data' must be array('B')") # in_data pre-processing __in_data = isinstance(in_data, int) if __in_data: (in_data, in_num_bytes) = (array_u08(in_data), in_data) else: (in_data, in_num_bytes) = isinstance(in_data, ArrayType) and (in_data, len(in_data)) or (in_data[0], min(len(in_data[0]), int(in_data[1]))) if in_data.typecode != 'B': raise TypeError("type for 'in_data' must be array('B')") # Call API function (_ret_, num_written, num_read) = api.py_aa_i2c_write_read(aardvark, slave_addr, flags, out_num_bytes, out_data, in_num_bytes, in_data) # in_data post-processing if __in_data: del in_data[max(0, min(num_read, len(in_data))):] return (_ret_, num_written, in_data, num_read) # Enable/Disable the Aardvark as an I2C slave device
def aa_i2c_slave_read (aardvark, data_in): """usage: (int return, u08 addr, u08[] data_in) = aa_i2c_slave_read(Aardvark aardvark, u08[] data_in) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function. Additionally, for arrays that are filled by the API function, an integer can be passed in place of the array argument and the API will automatically create an array of that length. All output arrays, whether passed in or generated, are passed back in the returned tuple.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # data_in pre-processing __data_in = isinstance(data_in, int) if __data_in: (data_in, num_bytes) = (array_u08(data_in), data_in) else: (data_in, num_bytes) = isinstance(data_in, ArrayType) and (data_in, len(data_in)) or (data_in[0], min(len(data_in[0]), int(data_in[1]))) if data_in.typecode != 'B': raise TypeError("type for 'data_in' must be array('B')") # Call API function (_ret_, addr) = api.py_aa_i2c_slave_read(aardvark, num_bytes, data_in) # data_in post-processing if __data_in: del data_in[max(0, min(_ret_, len(data_in))):] return (_ret_, addr, data_in) # Extended functions that return status code
def aa_i2c_slave_read_ext (aardvark, data_in): """usage: (int return, u08 addr, u08[] data_in, u16 num_read) = aa_i2c_slave_read_ext(Aardvark aardvark, u08[] data_in) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function. Additionally, for arrays that are filled by the API function, an integer can be passed in place of the array argument and the API will automatically create an array of that length. All output arrays, whether passed in or generated, are passed back in the returned tuple.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # data_in pre-processing __data_in = isinstance(data_in, int) if __data_in: (data_in, num_bytes) = (array_u08(data_in), data_in) else: (data_in, num_bytes) = isinstance(data_in, ArrayType) and (data_in, len(data_in)) or (data_in[0], min(len(data_in[0]), int(data_in[1]))) if data_in.typecode != 'B': raise TypeError("type for 'data_in' must be array('B')") # Call API function (_ret_, addr, num_read) = api.py_aa_i2c_slave_read_ext(aardvark, num_bytes, data_in) # data_in post-processing if __data_in: del data_in[max(0, min(num_read, len(data_in))):] return (_ret_, addr, data_in, num_read) # Enable the I2C bus monitor # This disables all other functions on the Aardvark adapter
def aa_i2c_monitor_read (aardvark, data): """usage: (int return, u16[] data) = aa_i2c_monitor_read(Aardvark aardvark, u16[] data) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function. Additionally, for arrays that are filled by the API function, an integer can be passed in place of the array argument and the API will automatically create an array of that length. All output arrays, whether passed in or generated, are passed back in the returned tuple.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # data pre-processing __data = isinstance(data, int) if __data: (data, num_bytes) = (array_u16(data), data) else: (data, num_bytes) = isinstance(data, ArrayType) and (data, len(data)) or (data[0], min(len(data[0]), int(data[1]))) if data.typecode != 'H': raise TypeError("type for 'data' must be array('H')") # Call API function (_ret_) = api.py_aa_i2c_monitor_read(aardvark, num_bytes, data) # data post-processing if __data: del data[max(0, min(_ret_, len(data))):] return (_ret_, data) # Configure the I2C pullup resistors. # This is only supported on hardware versions >= 2.00
def aa_spi_slave_read (aardvark, data_in): """usage: (int return, u08[] data_in) = aa_spi_slave_read(Aardvark aardvark, u08[] data_in) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function. Additionally, for arrays that are filled by the API function, an integer can be passed in place of the array argument and the API will automatically create an array of that length. All output arrays, whether passed in or generated, are passed back in the returned tuple.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # data_in pre-processing __data_in = isinstance(data_in, int) if __data_in: (data_in, num_bytes) = (array_u08(data_in), data_in) else: (data_in, num_bytes) = isinstance(data_in, ArrayType) and (data_in, len(data_in)) or (data_in[0], min(len(data_in[0]), int(data_in[1]))) if data_in.typecode != 'B': raise TypeError("type for 'data_in' must be array('B')") # Call API function (_ret_) = api.py_aa_spi_slave_read(aardvark, num_bytes, data_in) # data_in post-processing if __data_in: del data_in[max(0, min(_ret_, len(data_in))):] return (_ret_, data_in) # Change the output polarity on the SS line. # # Note: When configured as an SPI slave, the Aardvark will # always be setup with SS as active low. Hence this function # only affects the SPI master functions on the Aardvark. # enum AardvarkSpiSSPolarity
def aa_find_devices_ext (devices, unique_ids): """usage: (int return, u16[] devices, u32[] unique_ids) = aa_find_devices_ext(u16[] devices, u32[] unique_ids) All arrays can be passed into the API as an ArrayType object or as a tuple (array, length), where array is an ArrayType object and length is an integer. The user-specified length would then serve as the length argument to the API funtion (please refer to the product datasheet). If only the array is provided, the array's intrinsic length is used as the argument to the underlying API function. Additionally, for arrays that are filled by the API function, an integer can be passed in place of the array argument and the API will automatically create an array of that length. All output arrays, whether passed in or generated, are passed back in the returned tuple.""" if not AA_LIBRARY_LOADED: return AA_INCOMPATIBLE_LIBRARY # devices pre-processing __devices = isinstance(devices, int) if __devices: (devices, num_devices) = (array_u16(devices), devices) else: (devices, num_devices) = isinstance(devices, ArrayType) and (devices, len(devices)) or (devices[0], min(len(devices[0]), int(devices[1]))) if devices.typecode != 'H': raise TypeError("type for 'devices' must be array('H')") # unique_ids pre-processing __unique_ids = isinstance(unique_ids, int) if __unique_ids: (unique_ids, num_ids) = (array_u32(unique_ids), unique_ids) else: (unique_ids, num_ids) = isinstance(unique_ids, ArrayType) and (unique_ids, len(unique_ids)) or (unique_ids[0], min(len(unique_ids[0]), int(unique_ids[1]))) if unique_ids.typecode != 'I': raise TypeError("type for 'unique_ids' must be array('I')") # Call API function (_ret_) = api.py_aa_find_devices_ext(num_devices, num_ids, devices, unique_ids) # devices post-processing if __devices: del devices[max(0, min(_ret_, len(devices))):] # unique_ids post-processing if __unique_ids: del unique_ids[max(0, min(_ret_, len(unique_ids))):] return (_ret_, devices, unique_ids) # Open the Aardvark port. # # The port number is a zero-indexed integer. # # The port number is the same as that obtained from the # aa_find_devices() function above. # # Returns an Aardvark handle, which is guaranteed to be # greater than zero if it is valid. # # This function is recommended for use in simple applications # where extended information is not required. For more complex # applications, the use of aa_open_ext() is recommended.
