From 7f41f650de449c74e07ad35e0c944699eba7949c Mon Sep 17 00:00:00 2001 From: Daniel Campora Date: Wed, 25 Mar 2015 16:56:14 +0100 Subject: [PATCH] cc3200: Remove superflous params from the I2C API. --- cc3200/mods/pybi2c.c | 157 +++++++++++++++--------------------------- cc3200/mods/pybspi.c | 2 +- cc3200/qstrdefsport.h | 3 - 3 files changed, 55 insertions(+), 107 deletions(-) diff --git a/cc3200/mods/pybi2c.c b/cc3200/mods/pybi2c.c index 2befb7d324..5b22c653d8 100644 --- a/cc3200/mods/pybi2c.c +++ b/cc3200/mods/pybi2c.c @@ -57,8 +57,8 @@ /// from pyb import I2C /// /// i2c = I2C() # create -/// i2c = I2C(I2C.MASTER) # create and init as a master -/// i2c.init(I2C.MASTER, baudrate=20000) # init as a master +/// i2c = I2C(50000) # create and init with a 50KHz baudrate +/// i2c.init(100000) # init with a 100KHz baudrate /// i2c.deinit() # turn off the peripheral /// /// Printing the i2c object gives you information about its configuration. @@ -74,25 +74,21 @@ /// data = bytearray(3) # create a buffer /// i2c.recv(data) # receive 3 bytes, writing them into data /// -/// You can specify a timeout (in ms): -/// -/// i2c.send(b'123', timeout=20) # timout after 20ms if the other end is not responding -/// /// A master must specify the recipient's address: /// -/// i2c.init(I2C.MASTER) +/// i2c.init(100000) /// i2c.send('123', 0x42) # send 3 bytes to slave with address 0x42 /// i2c.send(b'456', addr=0x42) # keyword for address /// /// 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=10) - +/// 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 3 bytes to memory of slave 0x42, +/// # starting at address 2 in the slave typedef struct _pyb_i2c_obj_t { mp_obj_base_t base; @@ -102,14 +98,10 @@ typedef struct _pyb_i2c_obj_t { /****************************************************************************** DEFINE CONSTANTS ******************************************************************************/ -#define PYBI2C_MODE_MASTER (0) -#define PYBI2C_MODE_SLAVE (1) - #define PYBI2C_MIN_BAUD_RATE_HZ (50000) -#define PYBI2C_DEF_BAUD_RATE_HZ (100000) #define PYBI2C_MAX_BAUD_RATE_HZ (400000) -#define PYBI2C_DEF_TIMEOUT_MS (5) +#define PYBI2C_TRANSC_TIMEOUT_MS (10) #define PYBI2C_TRANSAC_WAIT_DELAY_US (10) #define PYBI2C_TIMEOUT_TO_COUNT(to_us, baud) (((baud) * to_us) / 16000000) @@ -144,10 +136,10 @@ STATIC void i2c_deinit(void) { pyb_i2c_obj.baudrate = 0; } -STATIC bool pyb_i2c_transaction(uint cmd, int timeout) { +STATIC bool pyb_i2c_transaction(uint cmd) { + // Convert the timeout to microseconds + int32_t timeout = PYBI2C_TRANSC_TIMEOUT_MS * 1000; // Sanity check, t_timeout must be between 1 and 255 - // convert timeout to microseconds - timeout = timeout > 0 ? (timeout * 1000) : 1000; uint t_timeout = MIN(PYBI2C_TIMEOUT_TO_COUNT(timeout, pyb_i2c_obj.baudrate), 255); // Clear all interrupts MAP_I2CMasterIntClearEx(I2CA0_BASE, MAP_I2CMasterIntStatusEx(I2CA0_BASE, false)); @@ -162,11 +154,12 @@ STATIC bool pyb_i2c_transaction(uint cmd, int timeout) { UtilsDelay(UTILS_DELAY_US_TO_COUNT(PYBI2C_TRANSAC_WAIT_DELAY_US)); timeout -= PYBI2C_TRANSAC_WAIT_DELAY_US; if (timeout < 0) { + // the peripheral is not responding, so stop return false; } } - // Check for any errors in transfer + // Check for any errors in the transfer if (MAP_I2CMasterErr(I2CA0_BASE) != I2C_MASTER_ERR_NONE) { switch(cmd) { case I2C_MASTER_CMD_BURST_SEND_START: @@ -184,35 +177,34 @@ STATIC bool pyb_i2c_transaction(uint cmd, int timeout) { } return false; } - return true; } -STATIC bool pyb_i2c_write(byte devAddr, byte *data, uint len, bool stop, int timeout) { +STATIC bool pyb_i2c_write(byte devAddr, byte *data, uint len, bool stop) { // Set I2C codec slave address MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, devAddr, false); // Write the first byte to the controller. MAP_I2CMasterDataPut(I2CA0_BASE, *data++); // Initiate the transfer. - RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_START, timeout)); + RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_START)); // Loop until the completion of transfer or error while (--len) { // Write the next byte of data MAP_I2CMasterDataPut(I2CA0_BASE, *data++); // Transact over I2C to send the byte - RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_CONT, timeout)); + RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_CONT)); } // If a stop bit is to be sent, send it. if (stop) { - RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_STOP, timeout)); + RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_STOP)); } return true; } -STATIC bool pyb_i2c_read(byte devAddr, byte *data, uint len, int timeout) { +STATIC bool pyb_i2c_read(byte devAddr, byte *data, uint len) { uint cmd; // Set I2C codec slave address @@ -229,7 +221,7 @@ STATIC bool pyb_i2c_read(byte devAddr, byte *data, uint len, int timeout) { } // Initiate the transfer. - RET_IF_ERR(pyb_i2c_transaction(cmd, timeout)); + RET_IF_ERR(pyb_i2c_transaction(cmd)); // Decrement the count len--; // Loop until the completion of reception or error @@ -238,11 +230,11 @@ STATIC bool pyb_i2c_read(byte devAddr, byte *data, uint len, int timeout) { *data++ = MAP_I2CMasterDataGet(I2CA0_BASE); if (--len) { // Continue with reception - RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_RECEIVE_CONT, timeout)); + RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_RECEIVE_CONT)); } else { // Complete the last reception - RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_RECEIVE_FINISH, timeout)); + RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_RECEIVE_FINISH)); } } @@ -252,11 +244,11 @@ STATIC bool pyb_i2c_read(byte devAddr, byte *data, uint len, int timeout) { return true; } -STATIC bool pyb_i2c_scan_device(byte devAddr, int timeout) { +STATIC bool pyb_i2c_scan_device(byte devAddr) { // Set I2C codec slave address MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, devAddr, true); // Initiate the transfer. - RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_SINGLE_RECEIVE, timeout)); + RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_SINGLE_RECEIVE)); // Since this is a hack, send the stop bit anyway MAP_I2CMasterControl(I2CA0_BASE, I2C_MASTER_CMD_BURST_SEND_ERROR_STOP); @@ -267,34 +259,15 @@ STATIC bool pyb_i2c_scan_device(byte devAddr, int timeout) { /* Micro Python bindings */ /******************************************************************************/ -/// \method init(mode, *, addr=0x12, baudrate=100000) +/// \method init(100000) /// -/// Initialise the I2C bus with the given parameters: +/// Initialise the I2C bus as a master with the given baudrate. /// -/// - `mode` must be either `I2C.MASTER` or `I2C.SLAVE` -/// - `addr` is the 7-bit address (only sensible for a slave) -/// - `baudrate` is the SCL clock rate (only sensible for a master) -STATIC const mp_arg_t pyb_i2c_init_args[] = { - { MP_QSTR_mode, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = PYBI2C_MODE_MASTER} }, - { MP_QSTR_addr, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} }, - { MP_QSTR_baudrate, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = PYBI2C_DEF_BAUD_RATE_HZ} }, -}; -#define PYB_I2C_INIT_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_init_args) - -STATIC mp_obj_t pyb_i2c_init_helper(pyb_i2c_obj_t *self_in, mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) { +STATIC mp_obj_t pyb_i2c_init_helper(pyb_i2c_obj_t *self_in, mp_obj_t baudrate) { pyb_i2c_obj_t *self = self_in; - // parse args - mp_arg_val_t vals[PYB_I2C_INIT_NUM_ARGS]; - mp_arg_parse_all(n_args, args, kw_args, PYB_I2C_INIT_NUM_ARGS, pyb_i2c_init_args, vals); - - if (vals[0].u_int != PYBI2C_MODE_MASTER) { - // thrown an exception since only master mode is supported - nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments)); - } - // make sure the baudrate is between the valid range - self->baudrate = MIN(MAX(vals[2].u_int, PYBI2C_MIN_BAUD_RATE_HZ), PYBI2C_MAX_BAUD_RATE_HZ); + self->baudrate = MIN(MAX(mp_obj_get_int(baudrate), PYBI2C_MIN_BAUD_RATE_HZ), PYBI2C_MAX_BAUD_RATE_HZ); // init the I2C bus i2c_init(self); @@ -316,23 +289,13 @@ STATIC mp_obj_t pyb_i2c_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n // check arguments mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true); - // get i2c number - mp_int_t i2c_id = mp_obj_get_int(args[0]); - - // check the i2c number - if (i2c_id != 0) { - nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments)); - } - // setup the object pyb_i2c_obj_t *self = &pyb_i2c_obj; self->base.type = &pyb_i2c_type; - if (n_args > 1 || n_kw > 0) { + if (n_args > 0) { // start the peripheral - mp_map_t kw_args; - mp_map_init_fixed_table(&kw_args, n_kw, args + n_args); - pyb_i2c_init_helper(self, n_args - 1, args + 1, &kw_args); + pyb_i2c_init_helper(self, *args); } return (mp_obj_t)self; @@ -348,10 +311,10 @@ STATIC void pyb_i2c_print(void (*print)(void *env, const char *fmt, ...), void * } } -STATIC mp_obj_t pyb_i2c_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) { - return pyb_i2c_init_helper(args[0], n_args - 1, args + 1, kw_args); +STATIC mp_obj_t pyb_i2c_init(mp_obj_t self_in, mp_obj_t baudrate) { + return pyb_i2c_init_helper(self_in, baudrate); } -STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_init_obj, 1, pyb_i2c_init); +STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_i2c_init_obj, pyb_i2c_init); /// \method deinit() /// Turn off the I2C bus. @@ -367,12 +330,11 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_i2c_deinit_obj, pyb_i2c_deinit); /// Check if an I2C device responds to the given address. Only valid when in master mode. STATIC mp_obj_t pyb_i2c_is_ready(mp_obj_t self_in, mp_obj_t i2c_addr_o) { mp_uint_t i2c_addr = mp_obj_get_int(i2c_addr_o); - for (int i = 0; i < 10; i++) { - if (pyb_i2c_scan_device(i2c_addr, PYBI2C_DEF_TIMEOUT_MS)) { + for (int i = 0; i < 7; i++) { + if (pyb_i2c_scan_device(i2c_addr)) { return mp_const_true; } } - return mp_const_false; } STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_i2c_is_ready_obj, pyb_i2c_is_ready); @@ -383,8 +345,8 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_i2c_is_ready_obj, pyb_i2c_is_ready); STATIC mp_obj_t pyb_i2c_scan(mp_obj_t self_in) { mp_obj_t list = mp_obj_new_list(0, NULL); for (uint addr = 1; addr <= 127; addr++) { - for (int i = 0; i < 10; i++) { - if (pyb_i2c_scan_device(addr, PYBI2C_DEF_TIMEOUT_MS)) { + for (int i = 0; i < 7; i++) { + if (pyb_i2c_scan_device(addr)) { mp_obj_list_append(list, mp_obj_new_int(addr)); break; } @@ -400,12 +362,10 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_i2c_scan_obj, pyb_i2c_scan); /// /// - `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 other end to respond /// Return value: `None`. STATIC const mp_arg_t pyb_i2c_send_args[] = { { MP_QSTR_send, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, { MP_QSTR_addr, MP_ARG_INT, {.u_int = 0} }, - { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = PYBI2C_DEF_TIMEOUT_MS} }, }; #define PYB_I2C_SEND_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_send_args) @@ -420,7 +380,7 @@ STATIC mp_obj_t pyb_i2c_send(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *k pyb_buf_get_for_send(vals[0].u_obj, &bufinfo, data); // send the data - if (!pyb_i2c_write(vals[1].u_int, bufinfo.buf, bufinfo.len, true, vals[2].u_int)) { + if (!pyb_i2c_write(vals[1].u_int, bufinfo.buf, bufinfo.len, true)) { nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed)); } @@ -428,21 +388,19 @@ STATIC mp_obj_t pyb_i2c_send(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *k } STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_send_obj, 1, pyb_i2c_send); -/// \method recv(recv, addr=0x00, timeout=10) +/// \method 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) -/// - `timeout` is the timeout in milliseconds to wait for the other end to respond /// /// 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`. STATIC const mp_arg_t pyb_i2c_recv_args[] = { { MP_QSTR_recv, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, { MP_QSTR_addr, MP_ARG_INT, {.u_int = 0} }, - { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = PYBI2C_DEF_TIMEOUT_MS} }, }; #define PYB_I2C_RECV_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_recv_args) @@ -456,7 +414,7 @@ STATIC mp_obj_t pyb_i2c_recv(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *k mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &vstr); // receive the data - if (!pyb_i2c_read(vals[1].u_int, (byte *)vstr.buf, vstr.len, vals[2].u_int)) { + if (!pyb_i2c_read(vals[1].u_int, (byte *)vstr.buf, vstr.len)) { nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed)); } @@ -470,15 +428,14 @@ STATIC mp_obj_t pyb_i2c_recv(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *k } STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_recv_obj, 1, pyb_i2c_recv); -/// \method mem_read(data, addr, memaddr, timeout=10, addr_size=8) +/// \method mem_read(data, addr, memaddr, addr_size=8) /// /// Read from the memory of an I2C device: /// /// - `data` can be an integer 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 other end to respond -/// - `addr_size` selects width of memaddr: 8 or 16 bits +/// - `addr_size` selects the width of memaddr: 8 or 16 bits /// /// Returns the read data. /// This is only valid in master mode. @@ -486,7 +443,6 @@ STATIC const mp_arg_t pyb_i2c_mem_read_args[] = { { MP_QSTR_data, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, { 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 = PYBI2C_DEF_TIMEOUT_MS} }, { 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) @@ -503,13 +459,13 @@ STATIC mp_obj_t pyb_i2c_mem_read(mp_uint_t n_args, const mp_obj_t *args, mp_map_ // get the addresses mp_uint_t i2c_addr = vals[1].u_int; mp_uint_t mem_addr = vals[2].u_int; - // determine width of mem_addr (1 or 2 bytes) - mp_uint_t mem_addr_size = vals[4].u_int >> 3; + // determine the width of mem_addr (1 or 2 bytes) + mp_uint_t mem_addr_size = vals[3].u_int >> 3; // Write the register address to be read from. - if (pyb_i2c_write (i2c_addr, (byte *)&mem_addr, mem_addr_size, false, vals[3].u_int)) { + if (pyb_i2c_write (i2c_addr, (byte *)&mem_addr, mem_addr_size, false)) { // Read the specified length of data - if (pyb_i2c_read (i2c_addr, (byte *)vstr.buf, vstr.len, vals[3].u_int)) { + if (pyb_i2c_read (i2c_addr, (byte *)vstr.buf, vstr.len)) { // return the read data if (o_ret != MP_OBJ_NULL) { return o_ret; @@ -525,15 +481,14 @@ STATIC mp_obj_t pyb_i2c_mem_read(mp_uint_t n_args, const mp_obj_t *args, mp_map_ } STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_mem_read_obj, 1, pyb_i2c_mem_read); -/// \method mem_write(data, addr, memaddr, timeout=10, addr_size=8) +/// \method mem_write(data, addr, memaddr, 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 other end to respond -/// - `addr_size` selects width of memaddr: 8 or 16 bits +/// - `addr_size` selects the width of memaddr: 8 or 16 bits /// /// Returns `None`. /// This is only valid in master mode. @@ -550,13 +505,13 @@ STATIC mp_obj_t pyb_i2c_mem_write(mp_uint_t n_args, const mp_obj_t *args, mp_map // get the addresses mp_uint_t i2c_addr = vals[1].u_int; mp_uint_t mem_addr = vals[2].u_int; - // determine width of mem_addr (1 or 2 bytes) - mp_uint_t mem_addr_size = vals[4].u_int >> 3; + // determine the width of mem_addr (1 or 2 bytes) + mp_uint_t mem_addr_size = vals[3].u_int >> 3; // Write the register address to write to. - if (pyb_i2c_write (i2c_addr, (byte *)&mem_addr, mem_addr_size, false, vals[3].u_int)) { + if (pyb_i2c_write (i2c_addr, (byte *)&mem_addr, mem_addr_size, false)) { // Write the specified length of data - if (pyb_i2c_write (i2c_addr, bufinfo.buf, bufinfo.len, true, vals[3].u_int)) { + if (pyb_i2c_write (i2c_addr, bufinfo.buf, bufinfo.len, true)) { return mp_const_none; } } @@ -577,10 +532,6 @@ STATIC const mp_map_elem_t pyb_i2c_locals_dict_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR_recv), (mp_obj_t)&pyb_i2c_recv_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_mem_read), (mp_obj_t)&pyb_i2c_mem_read_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_mem_write), (mp_obj_t)&pyb_i2c_mem_write_obj }, - - // class constants - /// \constant MASTER - for initialising the bus to master mode - { MP_OBJ_NEW_QSTR(MP_QSTR_MASTER), MP_OBJ_NEW_SMALL_INT(PYBI2C_MODE_MASTER) }, }; STATIC MP_DEFINE_CONST_DICT(pyb_i2c_locals_dict, pyb_i2c_locals_dict_table); diff --git a/cc3200/mods/pybspi.c b/cc3200/mods/pybspi.c index e047c7a6a7..eadd7f76b2 100644 --- a/cc3200/mods/pybspi.c +++ b/cc3200/mods/pybspi.c @@ -174,7 +174,7 @@ STATIC void pyb_spi_print(void (*print)(void *env, const char *fmt, ...), void * pyb_spi_obj_t *self = self_in; if (self->baudrate > 0) { - print(env, "", self->baudrate, self->config, self->submode, (self->wlen * 8)); } else { diff --git a/cc3200/qstrdefsport.h b/cc3200/qstrdefsport.h index f339584703..6e5010ebf1 100644 --- a/cc3200/qstrdefsport.h +++ b/cc3200/qstrdefsport.h @@ -126,13 +126,11 @@ Q(FLOW_TXRX) // for I2C class Q(I2C) -Q(mode) Q(addr) Q(baudrate) Q(data) Q(memaddr) Q(addr_size) -Q(timeout) Q(init) Q(deinit) Q(is_ready) @@ -141,7 +139,6 @@ Q(send) Q(recv) Q(mem_read) Q(mem_write) -Q(MASTER) // for ADC class Q(ADC)