tests/wipy: Add I2C tests.

cc3200/mods/pybi2c.c

@@ -137,6 +137,57 @@ STATIC bool pyb_i2c_transaction(uint cmd) {
     return true;
 }
 
+STATIC void pyb_i2c_check_init(pyb_i2c_obj_t *self) {
+    // not initialized
+    if (!self->baudrate) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
+    }
+}
+
+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));
+    // Since this is a hack, send the stop bit anyway
+    MAP_I2CMasterControl(I2CA0_BASE, I2C_MASTER_CMD_BURST_SEND_ERROR_STOP);
+    return true;
+}
+
+STATIC bool pyb_i2c_mem_addr_write (byte addr, byte *mem_addr, uint mem_addr_len) {
+    // Set I2C codec slave address
+    MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, addr, false);
+    // Write the first byte to the controller.
+    MAP_I2CMasterDataPut(I2CA0_BASE, *mem_addr++);
+    // Initiate the transfer.
+    RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_START));
+
+    // Loop until the completion of transfer or error
+    while (--mem_addr_len) {
+        // Write the next byte of data
+        MAP_I2CMasterDataPut(I2CA0_BASE, *mem_addr++);
+        // Transact over I2C to send the next byte
+        RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_CONT));
+    }
+    return true;
+}
+
+STATIC bool pyb_i2c_mem_write (byte addr, byte *mem_addr, uint mem_addr_len, byte *data, uint data_len) {
+    if (pyb_i2c_mem_addr_write (addr, mem_addr, mem_addr_len)) {
+        // Loop until the completion of transfer or error
+        while (data_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));
+        }
+        // send the stop bit
+        RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_STOP));
+        return true;
+    }
+    return false;
+}
+
 STATIC bool pyb_i2c_write(byte addr, byte *data, uint len, bool stop) {
     // Set I2C codec slave address
     MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, addr, false);
@@ -153,34 +204,20 @@ STATIC bool pyb_i2c_write(byte addr, byte *data, uint len, bool stop) {
         RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_CONT));
     }
 
-    // If a stop bit is to be sent, send it.
+    // If a stop bit is to be sent, do it.
     if (stop) {
         RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_STOP));
     }
-
     return true;
 }
 
 STATIC bool pyb_i2c_read(byte addr, byte *data, uint len) {
-    uint cmd;
+    // Initiate a burst or single receive sequence
-
+    uint cmd = --len > 0 ? I2C_MASTER_CMD_BURST_RECEIVE_START : I2C_MASTER_CMD_SINGLE_RECEIVE;
     // Set I2C codec slave address
     MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, addr, true);
-
-    // Check if its a single receive or burst receive
-    if (len > 1) {
-        // Initiate a burst receive sequence
-        cmd = I2C_MASTER_CMD_BURST_RECEIVE_START;
-    }
-    else {
-        // Configure for a single receive
-        cmd = I2C_MASTER_CMD_SINGLE_RECEIVE;
-    }
-
     // Initiate the transfer.
     RET_IF_ERR(pyb_i2c_transaction(cmd));
-    // Decrement the count
-    len--;
     // Loop until the completion of reception or error
     while (len) {
         // Receive the byte over I2C
@@ -188,8 +225,7 @@ STATIC bool pyb_i2c_read(byte addr, byte *data, uint len) {
         if (--len) {
             // Continue with reception
             RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_RECEIVE_CONT));
-        }
+        } else {
-        else {
             // Complete the last reception
             RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_RECEIVE_FINISH));
         }
@@ -197,22 +233,11 @@ STATIC bool pyb_i2c_read(byte addr, byte *data, uint len) {
 
     // Receive the last byte over I2C
     *data = MAP_I2CMasterDataGet(I2CA0_BASE);
-
-    return true;
-}
-
-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));
-    // Since this is a hack, send the stop bit anyway
-    MAP_I2CMasterControl(I2CA0_BASE, I2C_MASTER_CMD_BURST_SEND_ERROR_STOP);
-
     return true;
 }
 
 STATIC void pyb_i2c_read_into (mp_arg_val_t *args, vstr_t *vstr) {
+    pyb_i2c_check_init(&pyb_i2c_obj);
     // get the buffer to receive into
     pyb_buf_get_for_recv(args[1].u_obj, vstr);
 
@@ -223,6 +248,7 @@ STATIC void pyb_i2c_read_into (mp_arg_val_t *args, vstr_t *vstr) {
 }
 
 STATIC void pyb_i2c_readmem_into (mp_arg_val_t *args, vstr_t *vstr) {
+    pyb_i2c_check_init(&pyb_i2c_obj);
     // get the buffer to receive into
     pyb_buf_get_for_recv(args[2].u_obj, vstr);
 
@@ -232,8 +258,8 @@ STATIC void pyb_i2c_readmem_into (mp_arg_val_t *args, vstr_t *vstr) {
     // determine the width of mem_addr (1 or 2 bytes)
     mp_uint_t mem_addr_size = args[3].u_int >> 3;
 
-    // write the register address to be read from.
+    // write the register address to be read from
-    if (pyb_i2c_write (i2c_addr, (byte *)&mem_addr, mem_addr_size, false)) {
+    if (pyb_i2c_mem_addr_write (i2c_addr, (byte *)&mem_addr, mem_addr_size)) {
         // Read the specified length of data
         if (!pyb_i2c_read (i2c_addr, (byte *)vstr->buf, vstr->len)) {
             nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
@@ -255,7 +281,7 @@ STATIC void pyb_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_ki
 
 /// \method init()
 STATIC const mp_arg_t pyb_i2c_init_args[] = {
-    { MP_QSTR_mode,     MP_ARG_REQUIRED  | MP_ARG_INT, },
+    { MP_QSTR_mode,                        MP_ARG_INT, {.u_int = PYBI2C_MASTER} },
     { MP_QSTR_baudrate, MP_ARG_KW_ONLY   | MP_ARG_INT, {.u_int = 100000} },
     { MP_QSTR_pins,     MP_ARG_KW_ONLY   | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
 };
@@ -278,7 +304,7 @@ STATIC mp_obj_t pyb_i2c_init_helper(pyb_i2c_obj_t *self, mp_uint_t n_args, const
     mp_obj_t pins_o = args[2].u_obj;
     if (pins_o != mp_const_none) {
         mp_obj_t *pins;
-        mp_uint_t n_pins;
+        mp_uint_t n_pins = 2;
         if (pins_o == MP_OBJ_NULL) {
             // use the default pins
             pins = (mp_obj_t *)pyb_i2c_def_pin;
@@ -347,6 +373,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_i2c_deinit_obj, pyb_i2c_deinit);
 
 /// \method scan()
 STATIC mp_obj_t pyb_i2c_scan(mp_obj_t self_in) {
+    pyb_i2c_check_init(&pyb_i2c_obj);
     mp_obj_t list = mp_obj_new_list(0, NULL);
     for (uint addr = 1; addr <= 127; addr++) {
         for (int i = 0; i < 7; i++) {
@@ -362,11 +389,11 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_i2c_scan_obj, pyb_i2c_scan);
 
 STATIC mp_obj_t pyb_i2c_readfrom(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     STATIC const mp_arg_t pyb_i2c_readfrom_args[] = {
-        { MP_QSTR_addr,    MP_ARG_REQUIRED | MP_ARG_OBJ, },
+        { MP_QSTR_addr,    MP_ARG_REQUIRED | MP_ARG_INT, },
-        { MP_QSTR_nbytes,  MP_ARG_REQUIRED | MP_ARG_INT, },
+        { MP_QSTR_nbytes,  MP_ARG_REQUIRED | MP_ARG_OBJ, },
     };
 
-    // parse pos_args
+    // parse args
     mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_readfrom_args)];
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(pyb_i2c_readfrom_args), pyb_i2c_readfrom_args, args);
 
@@ -376,7 +403,7 @@ STATIC mp_obj_t pyb_i2c_readfrom(mp_uint_t n_args, const mp_obj_t *pos_args, mp_
     // return the received data
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_obj, 2, pyb_i2c_readfrom);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_obj, 3, pyb_i2c_readfrom);
 
 STATIC mp_obj_t pyb_i2c_readfrom_into(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     STATIC const mp_arg_t pyb_i2c_readfrom_into_args[] = {
@@ -394,7 +421,7 @@ STATIC mp_obj_t pyb_i2c_readfrom_into(mp_uint_t n_args, const mp_obj_t *pos_args
     // return the number of bytes received
     return mp_obj_new_int(vstr.len);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_into_obj, 2, pyb_i2c_readfrom_into);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_into_obj, 3, pyb_i2c_readfrom_into);
 
 STATIC mp_obj_t pyb_i2c_writeto(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     STATIC const mp_arg_t pyb_i2c_writeto_args[] = {
@@ -407,6 +434,8 @@ STATIC mp_obj_t pyb_i2c_writeto(mp_uint_t n_args, const mp_obj_t *pos_args, mp_m
     mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_writeto_args)];
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(pyb_i2c_writeto_args), pyb_i2c_writeto_args, args);
 
+    pyb_i2c_check_init(&pyb_i2c_obj);
+
     // get the buffer to send from
     mp_buffer_info_t bufinfo;
     uint8_t data[1];
@@ -420,13 +449,13 @@ STATIC mp_obj_t pyb_i2c_writeto(mp_uint_t n_args, const mp_obj_t *pos_args, mp_m
     // return the number of bytes written
     return mp_obj_new_int(bufinfo.len);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_writeto_obj, 2, pyb_i2c_writeto);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_writeto_obj, 3, pyb_i2c_writeto);
 
 STATIC mp_obj_t pyb_i2c_readfrom_mem(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     STATIC const mp_arg_t pyb_i2c_readfrom_mem_args[] = {
-        { MP_QSTR_addr,     MP_ARG_REQUIRED  | MP_ARG_OBJ, },
+        { MP_QSTR_addr,     MP_ARG_REQUIRED  | MP_ARG_INT, },
         { MP_QSTR_memaddr,  MP_ARG_REQUIRED  | MP_ARG_INT, },
-        { MP_QSTR_nbytes,   MP_ARG_REQUIRED  | MP_ARG_INT, },
+        { MP_QSTR_nbytes,   MP_ARG_REQUIRED  | MP_ARG_OBJ, },
         { MP_QSTR_addrsize, MP_ARG_KW_ONLY   | MP_ARG_INT, {.u_int = 8} },
     };
 
@@ -438,10 +467,10 @@ STATIC mp_obj_t pyb_i2c_readfrom_mem(mp_uint_t n_args, const mp_obj_t *pos_args,
     pyb_i2c_readmem_into (args, &vstr);
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_mem_obj, 3, pyb_i2c_readfrom_mem);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_mem_obj, 4, pyb_i2c_readfrom_mem);
 
 STATIC const mp_arg_t pyb_i2c_readfrom_mem_into_args[] = {
-    { MP_QSTR_addr,     MP_ARG_REQUIRED  | MP_ARG_OBJ, },
+    { MP_QSTR_addr,     MP_ARG_REQUIRED  | MP_ARG_INT, },
     { MP_QSTR_memaddr,  MP_ARG_REQUIRED  | MP_ARG_INT, },
     { MP_QSTR_buf,      MP_ARG_REQUIRED  | MP_ARG_OBJ, },
     { MP_QSTR_addrsize, MP_ARG_KW_ONLY   | MP_ARG_INT, {.u_int = 8} },
@@ -457,13 +486,15 @@ STATIC mp_obj_t pyb_i2c_readfrom_mem_into(mp_uint_t n_args, const mp_obj_t *pos_
     pyb_i2c_readmem_into (args, &vstr);
     return mp_obj_new_int(vstr.len);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_mem_into_obj, 3, pyb_i2c_readfrom_mem_into);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_mem_into_obj, 4, pyb_i2c_readfrom_mem_into);
 
 STATIC mp_obj_t pyb_i2c_writeto_mem(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     // parse args
     mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_readfrom_mem_into_args)];
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(pyb_i2c_readfrom_mem_into_args), pyb_i2c_readfrom_mem_into_args, args);
 
+    pyb_i2c_check_init(&pyb_i2c_obj);
+
     // get the buffer to write from
     mp_buffer_info_t bufinfo;
     uint8_t data[1];
@@ -476,17 +507,14 @@ STATIC mp_obj_t pyb_i2c_writeto_mem(mp_uint_t n_args, const mp_obj_t *pos_args,
     mp_uint_t mem_addr_size = args[3].u_int >> 3;
 
     // write the register address to write to.
-    if (pyb_i2c_write (i2c_addr, (byte *)&mem_addr, mem_addr_size, false)) {
+    if (pyb_i2c_mem_write (i2c_addr, (byte *)&mem_addr, mem_addr_size, bufinfo.buf, bufinfo.len)) {
-        // Write the specified length of data
+        // return the number of bytes written
-        if (pyb_i2c_write (i2c_addr, bufinfo.buf, bufinfo.len, true)) {
+        return mp_obj_new_int(bufinfo.len);
-            // return the number of bytes written
-            return mp_obj_new_int(bufinfo.len);
-        }
     }
 
     nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_writeto_mem_obj, 3, pyb_i2c_writeto_mem);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_writeto_mem_obj, 4, pyb_i2c_writeto_mem);
 
 STATIC const mp_map_elem_t pyb_i2c_locals_dict_table[] = {
     // instance methods
@@ -497,7 +525,7 @@ STATIC const mp_map_elem_t pyb_i2c_locals_dict_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR_readfrom_into),       (mp_obj_t)&pyb_i2c_readfrom_into_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_writeto),             (mp_obj_t)&pyb_i2c_writeto_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_readfrom_mem),        (mp_obj_t)&pyb_i2c_readfrom_mem_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_readfrom_mem_into),   (mp_obj_t)&pyb_i2c_readfrom_mem_into },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_readfrom_mem_into),   (mp_obj_t)&pyb_i2c_readfrom_mem_into_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_writeto_mem),         (mp_obj_t)&pyb_i2c_writeto_mem_obj },
 
     // class constants

cc3200/mods/pybuart.c

@@ -401,7 +401,7 @@ STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, mp_uint_t n_args, con
     uint flowcontrol = UART_FLOWCONTROL_NONE;
     if (pins_o != mp_const_none) {
         mp_obj_t *pins;
-        mp_uint_t n_pins;
+        mp_uint_t n_pins = 2;
         if (pins_o == MP_OBJ_NULL) {
             // use the default pins
             pins = (mp_obj_t *)pyb_uart_def_pin[self->uart_id];

tests/wipy/i2c.py

@@ -0,0 +1,165 @@
+'''
+I2C test for the CC3200 based boards.
+A MPU-9150 sensor must be connected to the I2C bus.
+'''
+
+from pyb import I2C
+from pyb import Pin
+import os
+import pyb
+
+machine = os.uname().machine
+if 'LaunchPad' in machine:
+    i2c_pins = ('GP11', 'GP10')
+elif 'WiPy' in machine:
+    i2c_pins = ('GP15', 'GP10')
+else:
+    raise Exception('Board not supported!')
+
+i2c = I2C(0, I2C.MASTER, baudrate=100000)
+print(i2c)
+i2c = I2C(0, mode=I2C.MASTER, baudrate=400000)
+print(i2c)
+i2c = I2C(0, mode=I2C.MASTER, baudrate=400000, pins=i2c_pins)
+print(i2c)
+
+addr = i2c.scan()[0]
+print(addr)
+
+reg = bytearray(1)
+reg2 = bytearray(2)
+reg2_r = bytearray(2)
+
+# reset the sensor
+reg[0] |= 0x80
+print(1 == i2c.writeto_mem(addr, 107, reg))
+pyb.delay(100)  # wait for the sensor to reset...
+
+print(1 == i2c.readfrom_mem_into(addr, 107, reg)) # read the power management register 1
+print(0x40 == reg[0])
+
+# now just read one byte
+data = i2c.readfrom_mem(addr, 117, 1) # read the "who am I?" register
+print(0x68 == data[0])
+print(len(data) == 1)
+print(1 == i2c.readfrom_mem_into(addr, 117, reg)) # read the "who am I?" register again
+print(0x68 == reg[0])
+
+# now try reading two bytes
+data = i2c.readfrom_mem(addr, 116, 2) # read the "who am I?" register
+print(0x68 == data[1])
+print(data == b'\x00\x68')
+print(len(data) == 2)
+print(2 == i2c.readfrom_mem_into(addr, 116, reg2)) # read the "who am I?" register again
+print(0x68 == reg2[1])
+print(reg2 == b'\x00\x68')
+
+print(1 == i2c.readfrom_mem_into(addr, 107, reg)) # read the power management register 1
+print(0x40 == reg[0])
+# clear the sleep bit
+reg[0] = 0
+print(1 == i2c.writeto_mem(addr, 107, reg))
+# read it back
+i2c.readfrom_mem_into(addr, 107, reg)
+print(0 == reg[0])
+
+# set the sleep bit
+reg[0] = 0x40
+print(1 == i2c.writeto_mem(addr, 107, reg))
+# read it back
+i2c.readfrom_mem_into(addr, 107, reg)
+print(0x40 == reg[0])
+
+# reset the sensor
+reg[0] |= 0x80
+print(1 == i2c.writeto_mem(addr, 107, reg))
+pyb.delay(100)  # wait for the sensor to reset...
+
+# now read and write two register at a time
+print(2 == i2c.readfrom_mem_into(addr, 107, reg2))
+print(0x40 == reg2[0])
+print(0x00 == reg2[1])
+# clear the sleep bit
+reg2[0] = 0
+# set some other bits
+reg2[1] |= 0x03
+print(2 == i2c.writeto_mem(addr, 107, reg2))
+# read it back
+i2c.readfrom_mem_into(addr, 107, reg2_r)
+print(reg2 == reg2_r)
+
+# reset the sensor
+reg[0] = 0x80
+print(1 == i2c.writeto_mem(addr, 107, reg))
+pyb.delay(100)  # wait for the sensor to reset...
+
+# try some raw read and writes
+reg[0] = 117 # register address
+print(1 == i2c.writeto(addr, reg, stop=False)) # just write the register address
+# now read
+print(1 == i2c.readfrom_into(addr, reg))
+print(reg[0] == 0x68)
+reg[0] = 117 # register address
+print(1 == i2c.writeto(addr, reg, stop=False)) # just write the register address
+# now read
+print(0x68 == i2c.readfrom(addr, 1)[0])
+
+i2c.readfrom_mem_into(addr, 107, reg2)
+print(0x40 == reg2[0])
+print(0x00 == reg2[1])
+
+reg2[0] = 107 # register address
+reg2[1] = 0
+print(2 == i2c.writeto(addr, reg2, stop=True)) # write the register address and the data
+i2c.readfrom_mem_into(addr, 107, reg) # check it back
+print(reg[0] == 0)
+
+# check for memory leaks...
+for i in range (0, 1000):
+    i2c = I2C(0, I2C.MASTER, baudrate=100000)
+
+# test deinit
+i2c = I2C(0, I2C.MASTER, baudrate=100000)
+i2c.deinit()
+print(i2c)
+
+# next ones should raise
+try:
+    i2c.scan()
+except Exception:
+    print("Exception")
+
+try:
+    i2c.readfrom(addr, 1)
+except Exception:
+    print("Exception")
+
+try:
+    i2c.readfrom_into(addr, reg)
+except Exception:
+    print("Exception")
+
+try:
+    i2c.readfrom_mem_into(addr, 107, reg)
+except Exception:
+    print("Exception")
+
+try:
+    i2c.writeto(addr, reg, stop=False)
+except Exception:
+    print("Exception")
+
+try:
+    i2c.writeto_mem(addr, 107, reg)
+except Exception:
+    print("Exception")
+
+try:
+    i2c.readfrom_mem(addr, 116, 2)
+except Exception:
+    print("Exception")
+
+# reinitialization must work
+i2c.init(baudrate=400000)
+print(i2c)
+

tests/wipy/i2c.py.exp

@@ -0,0 +1,48 @@
+I2C(0, I2C.MASTER, baudrate=100000)
+I2C(0, I2C.MASTER, baudrate=400000)
+I2C(0, I2C.MASTER, baudrate=400000)
+104
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+I2C(0)
+Exception
+Exception
+Exception
+Exception
+Exception
+Exception
+Exception
+I2C(0, I2C.MASTER, baudrate=400000)