From c6926c374dc0408d7ef8fa6385207430c122e6cf Mon Sep 17 00:00:00 2001 From: Daniel Campora Date: Sun, 2 Aug 2015 20:20:03 +0200 Subject: [PATCH] cc3200: Make I2C and SPI API the same as in stmhal. --- cc3200/mods/pybi2c.c | 3 + cc3200/mods/pybspi.c | 83 +++++++++++++------- cc3200/qstrdefsport.h | 2 + docs/library/pyb.I2C.rst | 162 +++++++++++---------------------------- docs/library/pyb.SPI.rst | 87 ++++++--------------- 5 files changed, 126 insertions(+), 211 deletions(-) diff --git a/cc3200/mods/pybi2c.c b/cc3200/mods/pybi2c.c index 2dac70098e..c9dfed91d8 100644 --- a/cc3200/mods/pybi2c.c +++ b/cc3200/mods/pybi2c.c @@ -380,6 +380,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_i2c_scan_obj, pyb_i2c_scan); STATIC const mp_arg_t pyb_i2c_send_args[] = { { MP_QSTR_send, MP_ARG_REQUIRED | MP_ARG_OBJ, }, { MP_QSTR_addr, MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} }, }; #define PYB_I2C_SEND_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_send_args) @@ -415,6 +416,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_send_obj, 1, pyb_i2c_send); STATIC const mp_arg_t pyb_i2c_recv_args[] = { { MP_QSTR_recv, MP_ARG_REQUIRED | MP_ARG_OBJ, }, { MP_QSTR_addr, MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} }, }; #define PYB_I2C_RECV_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_recv_args) @@ -457,6 +459,7 @@ STATIC const mp_arg_t pyb_i2c_mem_read_args[] = { { MP_QSTR_data, MP_ARG_REQUIRED | MP_ARG_OBJ, }, { MP_QSTR_addr, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, { MP_QSTR_memaddr, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} }, { MP_QSTR_addr_size, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 8} }, }; #define PYB_I2C_MEM_READ_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_mem_read_args) diff --git a/cc3200/mods/pybspi.c b/cc3200/mods/pybspi.c index c125626849..d452d1d03e 100644 --- a/cc3200/mods/pybspi.c +++ b/cc3200/mods/pybspi.c @@ -171,13 +171,12 @@ STATIC void pyb_spi_print(const mp_print_t *print, mp_obj_t self_in, mp_print_ki mp_printf(print, "", self->baudrate, (self->wlen * 8), self->polarity, self->phase, (self->config & SPI_CS_ACTIVELOW) ? MP_QSTR_ACTIVE_LOW : MP_QSTR_ACTIVE_HIGH); - } - else { + } else { mp_print_str(print, ""); } } -/// \method init(mode, *, baudrate=1000000, bits=8, polarity=0, phase=0, nss=SPI.ACTIVELOW) +/// \method init(mode, *, baudrate=1000000, bits=8, polarity=0, phase=0, nss=SPI.ACTIVE_LOW) /// /// Initialise the SPI bus with the given parameters: /// @@ -260,7 +259,6 @@ invalid_args: /// initialised (it has the settings from the last initialisation of /// the bus, if any). If extra arguments are given, the bus is initialised. /// See `init` for parameters of initialisation. -/// STATIC mp_obj_t pyb_spi_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) { // check arguments mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true); @@ -297,39 +295,59 @@ STATIC mp_obj_t pyb_spi_deinit(mp_obj_t self_in) { } STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_spi_deinit_obj, pyb_spi_deinit); -/// \method send(send) +/// \method send(send, *, timeout=5000) /// Send data on the bus: /// /// - `send` is the data to send (a byte to send, or a buffer object). +/// - `timeout` is the timeout in milliseconds to wait for the send. /// -STATIC mp_obj_t pyb_spi_send (mp_obj_t self_in, mp_obj_t send_o) { - pyb_spi_obj_t *self = self_in; +STATIC mp_obj_t pyb_spi_send (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) { + static const mp_arg_t allowed_args[] = { + { MP_QSTR_send, MP_ARG_REQUIRED | MP_ARG_OBJ, }, + { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} }, + }; + + // parse args + pyb_spi_obj_t *self = pos_args[0]; + mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args); + // get the buffer to send from mp_buffer_info_t bufinfo; uint8_t data[1]; - pyb_buf_get_for_send(send_o, &bufinfo, data); + pyb_buf_get_for_send(args[0].u_obj, &bufinfo, data); // just send pybspi_transfer(self, (const char *)bufinfo.buf, NULL, bufinfo.len); return mp_const_none; } -STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_spi_send_obj, pyb_spi_send); +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_spi_send_obj, 1, pyb_spi_send); -/// \method recv(recv) +/// \method recv(recv, *, timeout=5000) /// /// Receive data on the bus: /// /// - `recv` can be an integer, which is the number of bytes to receive, /// or a mutable buffer, which will be filled with received bytes. +/// - `timeout` is the timeout in milliseconds to wait for the receive. /// /// Return: if `recv` is an integer then a new buffer of the bytes received, /// otherwise the same buffer that was passed in to `recv`. -STATIC mp_obj_t pyb_spi_recv(mp_obj_t self_in, mp_obj_t recv_o) { - pyb_spi_obj_t *self = self_in; +STATIC mp_obj_t pyb_spi_recv(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) { + static const mp_arg_t allowed_args[] = { + { MP_QSTR_recv, MP_ARG_REQUIRED | MP_ARG_OBJ, }, + { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} }, + }; + + // parse args + pyb_spi_obj_t *self = pos_args[0]; + mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args); + // get the buffer to receive into vstr_t vstr; - mp_obj_t o_ret = pyb_buf_get_for_recv(recv_o, &vstr); + mp_obj_t o_ret = pyb_buf_get_for_recv(args[0].u_obj, &vstr); // just receive pybspi_transfer(self, NULL, vstr.buf, vstr.len); @@ -341,9 +359,9 @@ STATIC mp_obj_t pyb_spi_recv(mp_obj_t self_in, mp_obj_t recv_o) { return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr); } } -STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_spi_recv_obj, pyb_spi_recv); +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_spi_recv_obj, 1, pyb_spi_recv); -/// \method send_recv(send, recv) +/// \method send_recv(send, recv=None, *, timeout=5000) /// /// Send and receive data on the bus at the same time: /// @@ -351,10 +369,20 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_spi_recv_obj, pyb_spi_recv); /// - `recv` is a mutable buffer which will be filled with received bytes. /// It can be the same as `send`, or omitted. If omitted, a new buffer will /// be created. +/// - `timeout` is the timeout in milliseconds to wait for the transaction to complete. /// /// Return: the buffer with the received bytes. -STATIC mp_obj_t pyb_spi_send_recv (mp_uint_t n_args, const mp_obj_t *args) { - pyb_spi_obj_t *self = args[0]; +STATIC mp_obj_t pyb_spi_send_recv (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) { + static const mp_arg_t allowed_args[] = { + { MP_QSTR_send, MP_ARG_REQUIRED | MP_ARG_OBJ, }, + { MP_QSTR_recv, MP_ARG_OBJ, {.u_obj = mp_const_none} }, + { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} }, + }; + + // parse args + pyb_spi_obj_t *self = pos_args[0]; + mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args); // get buffers to send from/receive to mp_buffer_info_t bufinfo_send; @@ -363,35 +391,34 @@ STATIC mp_obj_t pyb_spi_send_recv (mp_uint_t n_args, const mp_obj_t *args) { vstr_t vstr_recv; mp_obj_t o_ret; - if (args[1] == args[2]) { + if (args[0].u_obj == args[1].u_obj) { // same object for sending and receiving, it must be a r/w buffer - mp_get_buffer_raise(args[1], &bufinfo_send, MP_BUFFER_RW); + mp_get_buffer_raise(args[0].u_obj, &bufinfo_send, MP_BUFFER_RW); bufinfo_recv = bufinfo_send; - o_ret = args[1]; + o_ret = args[0].u_obj; } else { // get the buffer to send from - pyb_buf_get_for_send(args[1], &bufinfo_send, data_send); + pyb_buf_get_for_send(args[0].u_obj, &bufinfo_send, data_send); // get the buffer to receive into - if (n_args == 2) { + if (args[1].u_obj == mp_const_none) { // only the send was argument given, so create a fresh buffer of the send length vstr_init_len(&vstr_recv, bufinfo_send.len); bufinfo_recv.len = vstr_recv.len; bufinfo_recv.buf = vstr_recv.buf; o_ret = MP_OBJ_NULL; - } - else { + } else { // recv argument given - mp_get_buffer_raise(args[2], &bufinfo_recv, MP_BUFFER_WRITE); + mp_get_buffer_raise(args[1].u_obj, &bufinfo_recv, MP_BUFFER_WRITE); if (bufinfo_recv.len != bufinfo_send.len) { nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments)); } - o_ret = args[2]; + o_ret = args[1].u_obj; } } // send and receive - pybspi_transfer(self, (const char *)bufinfo_send.buf, vstr_recv.buf, bufinfo_send.len); + pybspi_transfer(self, (const char *)bufinfo_send.buf, bufinfo_recv.buf, bufinfo_send.len); // return the received data if (o_ret != MP_OBJ_NULL) { @@ -400,7 +427,7 @@ STATIC mp_obj_t pyb_spi_send_recv (mp_uint_t n_args, const mp_obj_t *args) { return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr_recv); } } -STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_spi_send_recv_obj, 2, 3, pyb_spi_send_recv); +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_spi_send_recv_obj, 1, pyb_spi_send_recv); STATIC const mp_map_elem_t pyb_spi_locals_dict_table[] = { // instance methods diff --git a/cc3200/qstrdefsport.h b/cc3200/qstrdefsport.h index 1469924158..feda980ee0 100644 --- a/cc3200/qstrdefsport.h +++ b/cc3200/qstrdefsport.h @@ -166,6 +166,7 @@ Q(mode) Q(baudrate) Q(addr) Q(data) +Q(timeout) Q(memaddr) Q(addr_size) Q(init) @@ -348,6 +349,7 @@ Q(deinit) Q(send) Q(recv) Q(send_recv) +Q(timeout) Q(MASTER) Q(ACTIVE_LOW) Q(ACTIVE_HIGH) diff --git a/docs/library/pyb.I2C.rst b/docs/library/pyb.I2C.rst index d3cbed0574..7c22a700b9 100644 --- a/docs/library/pyb.I2C.rst +++ b/docs/library/pyb.I2C.rst @@ -45,11 +45,9 @@ To receive inplace, first create a bytearray:: data = bytearray(3) # create a buffer i2c.recv(data) # receive 3 bytes, writing them into data -.. only:: port_pyboard +You can specify a timeout (in ms):: - You can specify a timeout (in ms):: - - i2c.send(b'123', timeout=2000) # timout after 2 seconds + i2c.send(b'123', timeout=2000) # timout after 2 seconds A master must specify the recipient's address:: @@ -57,29 +55,15 @@ A master must specify the recipient's address:: i2c.send('123', 0x42) # send 3 bytes to slave with address 0x42 i2c.send(b'456', addr=0x42) # keyword for address -.. only:: port_pyboard - - Master also has other methods:: - - i2c.is_ready(0x42) # check if slave 0x42 is ready - i2c.scan() # scan for slaves on the bus, returning - # a list of valid addresses - i2c.mem_read(3, 0x42, 2) # read 3 bytes from memory of slave 0x42, - # starting at address 2 in the slave - i2c.mem_write('abc', 0x42, 2, timeout=1000) - -.. only:: port_wipy - - There are also other methods:: - - i2c.is_ready(0x42) # check if slave 0x42 is ready - i2c.scan() # scan for slaves on the bus, returning - # a list of valid addresses - i2c.mem_read(3, 0x42, 2) # read 3 bytes from memory of slave 0x42, - # starting at address 2 in the slave - i2c.mem_write('abc', 0x42, 2) # write 'abc' (3 bytes) to memory of slave 0x42 - # starting at address 2 in the slave +Master also has other methods:: + i2c.is_ready(0x42) # check if slave 0x42 is ready + i2c.scan() # scan for slaves on the bus, returning + # a list of valid addresses + i2c.mem_read(3, 0x42, 2) # read 3 bytes from memory of slave 0x42, + # starting at address 2 in the slave + i2c.mem_write('abc', 0x42, 2, timeout=1000) # write 'abc' (3 bytes) to memory of slave 0x42 + # starting at address 2 in the slave, timeout after 1 second Constructors ------------ @@ -102,7 +86,7 @@ Constructors .. only:: port_wipy .. class:: pyb.I2C(bus, ...) - + Construct an I2C object on the given bus. `bus` can only be 1. With no additional parameters, the I2C object is created but not initialised (it has the settings from the last initialisation of @@ -141,118 +125,58 @@ Methods Check if an I2C device responds to the given address. Only valid when in master mode. -.. only:: port_pyboard +.. method:: i2c.mem_read(data, addr, memaddr, timeout=5000, addr_size=8) - .. method:: i2c.mem_read(data, addr, memaddr, timeout=5000, addr_size=8) - - Read from the memory of an I2C device: - - - ``data`` can be an integer (number of bytes to read) or a buffer to read into - - ``addr`` is the I2C device address - - ``memaddr`` is the memory location within the I2C device - - ``timeout`` is the timeout in milliseconds to wait for the read - - ``addr_size`` selects width of memaddr: 8 or 16 bits + Read from the memory of an I2C device: - Returns the read data. - This is only valid in master mode. + - ``data`` can be an integer (number of bytes to read) or a buffer to read into + - ``addr`` is the I2C device address + - ``memaddr`` is the memory location within the I2C device + - ``timeout`` is the timeout in milliseconds to wait for the read + - ``addr_size`` selects width of memaddr: 8 or 16 bits -.. only:: port_wipy + Returns the read data. + This is only valid in master mode. - .. method:: i2c.mem_read(data, addr, memaddr, addr_size=8) - - Read from the memory of an I2C device: - - - ``data`` can be an integer (number of bytes to read) or a buffer to read into - - ``addr`` is the I2C device address - - ``memaddr`` is the memory location within the I2C device - - ``addr_size`` selects width of memaddr: 8 or 16 bits +.. method:: i2c.mem_write(data, addr, memaddr, timeout=5000, addr_size=8) - Returns the read data. - This is only valid in master mode. + Write to the memory of an I2C device: -.. only:: port_pyboard + - ``data`` can be an integer or a buffer to write from + - ``addr`` is the I2C device address + - ``memaddr`` is the memory location within the I2C device + - ``timeout`` is the timeout in milliseconds to wait for the write + - ``addr_size`` selects width of memaddr: 8 or 16 bits - .. method:: i2c.mem_write(data, addr, memaddr, timeout=5000, addr_size=8) - - Write to the memory of an I2C device: - - - ``data`` can be an integer or a buffer to write from - - ``addr`` is the I2C device address - - ``memaddr`` is the memory location within the I2C device - - ``timeout`` is the timeout in milliseconds to wait for the write - - ``addr_size`` selects width of memaddr: 8 or 16 bits + Returns ``None``. + This is only valid in master mode. - Returns ``None``. - This is only valid in master mode. +.. method:: i2c.recv(recv, addr=0x00, timeout=5000) -.. only:: port_wipy + Receive data on the bus: - .. method:: i2c.mem_write(data, addr, memaddr, timeout=5000, addr_size=8) - - Write to the memory of an I2C device: - - - ``data`` can be an integer or a buffer to write from - - ``addr`` is the I2C device address - - ``memaddr`` is the memory location within the I2C device - - ``addr_size`` selects width of memaddr: 8 or 16 bits - - Returns ``None``. - This is only valid in master mode. + - ``recv`` can be an integer, which is the number of bytes to receive, + or a mutable buffer, which will be filled with received bytes + - ``addr`` is the address to receive from (only required in master mode) + - ``timeout`` is the timeout in milliseconds to wait for the receive -.. only:: port_pyboard - - .. method:: i2c.recv(recv, addr=0x00, timeout=5000) - - Receive data on the bus: - - - ``recv`` can be an integer, which is the number of bytes to receive, - or a mutable buffer, which will be filled with received bytes - - ``addr`` is the address to receive from (only required in master mode) - - ``timeout`` is the timeout in milliseconds to wait for the receive - - Return value: if ``recv`` is an integer then a new buffer of the bytes received, - otherwise the same buffer that was passed in to ``recv``. - -.. only:: port_wipy - - .. method:: i2c.recv(recv, addr=0x00) - - Receive data on the bus: - - - ``recv`` can be an integer, which is the number of bytes to receive, - or a mutable buffer, which will be filled with received bytes - - ``addr`` is the address to receive from (only required in master mode) - - Return value: if ``recv`` is an integer then a new buffer of the bytes received, - otherwise the same buffer that was passed in to ``recv``. + Return value: if ``recv`` is an integer then a new buffer of the bytes received, + otherwise the same buffer that was passed in to ``recv``. .. method:: i2c.scan() Scan all I2C addresses from 0x01 to 0x7f and return a list of those that respond. Only valid when in master mode. -.. only:: port_pyboard +.. method:: i2c.send(send, addr=0x00, timeout=5000) - .. method:: i2c.send(send, addr=0x00, timeout=5000) - - Send data on the bus: - - - ``send`` is the data to send (an integer to send, or a buffer object) - - ``addr`` is the address to send to (only required in master mode) - - ``timeout`` is the timeout in milliseconds to wait for the send - - Return value: ``None``. + Send data on the bus: -.. only:: port_wipy + - ``send`` is the data to send (an integer to send, or a buffer object) + - ``addr`` is the address to send to (only required in master mode) + - ``timeout`` is the timeout in milliseconds to wait for the send - .. method:: i2c.send(send, addr=0x00) - - Send data on the bus: - - - ``send`` is the data to send (an integer to send, or a buffer object) - - ``addr`` is the address to send to (only required in master mode) - - Return value: ``None``. + Return value: ``None``. Constants --------- diff --git a/docs/library/pyb.SPI.rst b/docs/library/pyb.SPI.rst index d6f4bb9637..16aa3e20e1 100644 --- a/docs/library/pyb.SPI.rst +++ b/docs/library/pyb.SPI.rst @@ -25,7 +25,7 @@ there are 3 lines: SCK, MOSI, MISO. parameters to init the SPI bus:: from pyb import SPI - spi = SPI(1, SPI.MASTER, baudrate=600000, polarity=1, phase=0) + spi = SPI(1, SPI.MASTER, baudrate=1000000, polarity=0, phase=0, nss=SPI.ACTIVE_LOW) Only required parameter is mode, must be SPI.MASTER. Polarity can be 0 or 1, and is the level the idle clock line sits at. Phase can be 0 or 1 to @@ -105,7 +105,7 @@ Methods .. only:: port_wipy - .. method:: spi.init(mode, baudrate=328125, \*, polarity=1, phase=0, bits=8, nss=SPI.ACTIVE_LOW) + .. method:: spi.init(mode, baudrate=1000000, \*, polarity=0, phase=0, bits=8, nss=SPI.ACTIVE_LOW) Initialise the SPI bus with the given parameters: @@ -122,78 +122,37 @@ Methods Printing the SPI object will show you the computed baudrate and the chosen prescaler. -.. only:: port_pyboard +.. method:: spi.recv(recv, \*, timeout=5000) - .. method:: spi.recv(recv, \*, timeout=5000) - - Receive data on the bus: - - - ``recv`` can be an integer, which is the number of bytes to receive, - or a mutable buffer, which will be filled with received bytes. - - ``timeout`` is the timeout in milliseconds to wait for the receive. - - Return value: if ``recv`` is an integer then a new buffer of the bytes received, - otherwise the same buffer that was passed in to ``recv``. + Receive data on the bus: -.. only:: port_wipy + - ``recv`` can be an integer, which is the number of bytes to receive, + or a mutable buffer, which will be filled with received bytes. + - ``timeout`` is the timeout in milliseconds to wait for the receive. - .. method:: spi.recv(recv) - - Receive data on the bus: - - - ``recv`` can be an integer, which is the number of bytes to receive, - or a mutable buffer, which will be filled with received bytes. - - Return value: if ``recv`` is an integer then a new buffer of the bytes received, - otherwise the same buffer that was passed in to ``recv``. + Return value: if ``recv`` is an integer then a new buffer of the bytes received, + otherwise the same buffer that was passed in to ``recv``. -.. only:: port_pyboard +.. method:: spi.send(send, \*, timeout=5000) - .. method:: spi.send(send, \*, timeout=5000) - - Send data on the bus: - - - ``send`` is the data to send (an integer to send, or a buffer object). - - ``timeout`` is the timeout in milliseconds to wait for the send. - - Return value: ``None``. + Send data on the bus: -.. only:: port_wipy + - ``send`` is the data to send (an integer to send, or a buffer object). + - ``timeout`` is the timeout in milliseconds to wait for the send. - .. method:: spi.send(send) - - Send data on the bus: - - - ``send`` is the data to send (an integer to send, or a buffer object). - - Return value: ``None``. + Return value: ``None``. -.. only:: port_pyboard +.. method:: spi.send_recv(send, recv=None, \*, timeout=5000) - .. method:: spi.send_recv(send, recv=None, \*, timeout=5000) - - Send and receive data on the bus at the same time: - - - ``send`` is the data to send (an integer to send, or a buffer object). - - ``recv`` is a mutable buffer which will be filled with received bytes. - It can be the same as ``send``, or omitted. If omitted, a new buffer will - be created. - - ``timeout`` is the timeout in milliseconds to wait for the receive. - - Return value: the buffer with the received bytes. + Send and receive data on the bus at the same time: -.. only:: port_wipy + - ``send`` is the data to send (an integer to send, or a buffer object). + - ``recv`` is a mutable buffer which will be filled with received bytes. + It can be the same as ``send``, or omitted. If omitted, a new buffer will + be created. + - ``timeout`` is the timeout in milliseconds to wait for the receive. - .. method:: spi.send_recv(send, recv=None) - - Send and receive data on the bus at the same time: - - - ``send`` is the data to send (an integer to send, or a buffer object). - - ``recv`` is a mutable buffer which will be filled with received bytes. - It can be the same as ``send``, or omitted. If omitted, a new buffer will - be created. - - Return value: the buffer with the received bytes. + Return value: the buffer with the received bytes. Constants --------- @@ -219,4 +178,4 @@ Constants .. data:: SPI.ACTIVE_LOW .. data:: SPI.ACTIVE_HIGH - decides the polarity of the NSS pin + selects the polarity of the NSS pin