Update MicroPyhon and pico-sdk to current commit, update OC modules according to the changes in MP

micropython/modules/ev3_sensors/messages.h

@@ -5,7 +5,7 @@
 #define EV3_SENSOR_MESSAGES_H
 
 #include <stdint.h>
-#include <pico/platform.h>
+#include <pico.h>
 
 // Known sensor IDs
 typedef enum {

micropython/modules/ev3_sensors/micropython_api.c

@@ -26,13 +26,15 @@ typedef struct {
   int proper_id;
 } ev3_api_obj_t;
 
+const mp_obj_type_t ev3_api;
+
 static mp_obj_t new_data_memoryview(ev3_api_obj_t *self);
 static void raise_error_if_closed(ev3_api_obj_t *self);
 static void try_wait_for_sensor(ev3_api_obj_t *self, uint timeout_ms);
 static void try_wait_for_any_sensor(ev3_api_obj_t *self, uint timeout_ms);
 static void try_check_sensor_id(ev3_api_obj_t *self);
 
-STATIC mp_obj_t ev3_api_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+static mp_obj_t ev3_api_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
   mp_arg_check_num(n_args, n_kw, 2, 2, false);
 
   int port = mp_obj_get_int(args[0]);
@@ -56,7 +58,7 @@ STATIC mp_obj_t ev3_api_make_new(const mp_obj_type_t *type, size_t n_args, size_
     }
   }
 
-  ev3_api_obj_t *self = m_new_obj_with_finaliser(ev3_api_obj_t);
+  ev3_api_obj_t *self = mp_obj_malloc_with_finaliser(ev3_api_obj_t, &ev3_api);
   self->base.type = (mp_obj_type_t *) type;
   self->is_closed = false;
   self->proper_id = sensor_id;
@@ -74,7 +76,7 @@ STATIC mp_obj_t ev3_api_make_new(const mp_obj_type_t *type, size_t n_args, size_
 }
 
 
-STATIC mp_obj_t ev3_api_finalizer(mp_obj_t self_in) {
+static mp_obj_t ev3_api_finalizer(mp_obj_t self_in) {
   ev3_api_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
   if (!self->is_closed) {
@@ -84,10 +86,10 @@ STATIC mp_obj_t ev3_api_finalizer(mp_obj_t self_in) {
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_finalizer_obj, ev3_api_finalizer);
+static MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_finalizer_obj, ev3_api_finalizer);
 
 
-STATIC mp_obj_t ev3_api_is_connected(mp_obj_t self_in) {
+static mp_obj_t ev3_api_is_connected(mp_obj_t self_in) {
   ev3_api_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
   return mp_obj_new_bool(
@@ -95,10 +97,10 @@ STATIC mp_obj_t ev3_api_is_connected(mp_obj_t self_in) {
   );
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_is_connected_obj, ev3_api_is_connected);
+static MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_is_connected_obj, ev3_api_is_connected);
 
 
-STATIC mp_obj_t ev3_api_is_ready(mp_obj_t self_in) {
+static mp_obj_t ev3_api_is_ready(mp_obj_t self_in) {
   ev3_api_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
   return mp_obj_new_bool(
@@ -106,10 +108,10 @@ STATIC mp_obj_t ev3_api_is_ready(mp_obj_t self_in) {
   );
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_is_ready_obj, ev3_api_is_ready);
+static MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_is_ready_obj, ev3_api_is_ready);
 
 
-STATIC mp_obj_t ev3_api_set_mode(mp_obj_t self_in, mp_obj_t mode_in) {
+static mp_obj_t ev3_api_set_mode(mp_obj_t self_in, mp_obj_t mode_in) {
   ev3_api_obj_t *self = MP_OBJ_TO_PTR(self_in);
   raise_error_if_closed(self);
   try_wait_for_sensor(self, DEFAULT_WAIT_TIMEOUT_MS);
@@ -129,10 +131,10 @@ STATIC mp_obj_t ev3_api_set_mode(mp_obj_t self_in, mp_obj_t mode_in) {
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(ev3_api_set_mode_obj, ev3_api_set_mode);
+static MP_DEFINE_CONST_FUN_OBJ_2(ev3_api_set_mode_obj, ev3_api_set_mode);
 
 
-STATIC mp_obj_t ev3_api_write_command(mp_obj_t self_in, mp_obj_t buffer_in) {
+static mp_obj_t ev3_api_write_command(mp_obj_t self_in, mp_obj_t buffer_in) {
   ev3_api_obj_t *self = MP_OBJ_TO_PTR(self_in);
   raise_error_if_closed(self);
   try_wait_for_sensor(self, DEFAULT_WAIT_TIMEOUT_MS);
@@ -150,10 +152,10 @@ STATIC mp_obj_t ev3_api_write_command(mp_obj_t self_in, mp_obj_t buffer_in) {
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(ev3_api_write_command_obj, ev3_api_write_command);
+static MP_DEFINE_CONST_FUN_OBJ_2(ev3_api_write_command_obj, ev3_api_write_command);
 
 
-STATIC mp_obj_t ev3_api_reset(mp_obj_t self_in) {
+static mp_obj_t ev3_api_reset(mp_obj_t self_in) {
   ev3_api_obj_t *self = MP_OBJ_TO_PTR(self_in);
   raise_error_if_closed(self);
 
@@ -161,10 +163,10 @@ STATIC mp_obj_t ev3_api_reset(mp_obj_t self_in) {
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_reset_obj, ev3_api_reset);
+static MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_reset_obj, ev3_api_reset);
 
 
-STATIC mp_obj_t ev3_api_read(mp_obj_t self_in) {
+static mp_obj_t ev3_api_read(mp_obj_t self_in) {
   ev3_api_obj_t *self = MP_OBJ_TO_PTR(self_in);
   raise_error_if_closed(self);
   try_wait_for_sensor(self, DEFAULT_WAIT_TIMEOUT_MS);
@@ -181,10 +183,10 @@ STATIC mp_obj_t ev3_api_read(mp_obj_t self_in) {
   }
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_read_obj, ev3_api_read);
+static MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_read_obj, ev3_api_read);
 
 
-STATIC mp_obj_t ev3_api_read_mode(mp_obj_t self_in, mp_obj_t mode_in) {
+static mp_obj_t ev3_api_read_mode(mp_obj_t self_in, mp_obj_t mode_in) {
   ev3_api_obj_t *self = MP_OBJ_TO_PTR(self_in);
   raise_error_if_closed(self);
   try_wait_for_sensor(self, DEFAULT_WAIT_TIMEOUT_MS);
@@ -218,10 +220,10 @@ STATIC mp_obj_t ev3_api_read_mode(mp_obj_t self_in, mp_obj_t mode_in) {
   return new_data_memoryview(self);
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(ev3_api_read_mode_obj, ev3_api_read_mode);
+static MP_DEFINE_CONST_FUN_OBJ_2(ev3_api_read_mode_obj, ev3_api_read_mode);
 
 
-STATIC mp_obj_t ev3_api_get_sensor_id(mp_obj_t self_in) {
+static mp_obj_t ev3_api_get_sensor_id(mp_obj_t self_in) {
   ev3_api_obj_t *self = MP_OBJ_TO_PTR(self_in);
   raise_error_if_closed(self);
 
@@ -233,9 +235,9 @@ STATIC mp_obj_t ev3_api_get_sensor_id(mp_obj_t self_in) {
   }
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_get_sensor_id_obj, ev3_api_get_sensor_id);
+static MP_DEFINE_CONST_FUN_OBJ_1(ev3_api_get_sensor_id_obj, ev3_api_get_sensor_id);
 
-STATIC mp_obj_t ev3_api_waitfor(size_t n_args, const mp_obj_t *args) {
+static mp_obj_t ev3_api_waitfor(size_t n_args, const mp_obj_t *args) {
   ev3_api_obj_t *self = MP_OBJ_TO_PTR(args[0]);
   raise_error_if_closed(self);
 
@@ -248,7 +250,7 @@ STATIC mp_obj_t ev3_api_waitfor(size_t n_args, const mp_obj_t *args) {
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(ev3_api_waitfor_obj, 1, 2, ev3_api_waitfor);
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(ev3_api_waitfor_obj, 1, 2, ev3_api_waitfor);
 
 
 mp_obj_t new_data_memoryview(ev3_api_obj_t *self) {
@@ -325,7 +327,7 @@ void try_check_sensor_id(ev3_api_obj_t *self) {
   }
 }
 
-STATIC const mp_rom_map_elem_t ev3_api_locals_dict_table[] = {
+static const mp_rom_map_elem_t ev3_api_locals_dict_table[] = {
     {MP_ROM_QSTR(MP_QSTR_close),               MP_ROM_PTR(&ev3_api_finalizer_obj)},
     {MP_ROM_QSTR(MP_QSTR___del__),             MP_ROM_PTR(&ev3_api_finalizer_obj)},
     {MP_ROM_QSTR(MP_QSTR_is_connected),        MP_ROM_PTR(&ev3_api_is_connected_obj)},
@@ -338,7 +340,7 @@ STATIC const mp_rom_map_elem_t ev3_api_locals_dict_table[] = {
     {MP_ROM_QSTR(MP_QSTR_sensor_id),           MP_ROM_PTR(&ev3_api_get_sensor_id_obj)},
     {MP_ROM_QSTR(MP_QSTR_wait_for_connection), MP_ROM_PTR(&ev3_api_waitfor_obj)},
 };
-STATIC MP_DEFINE_CONST_DICT(ev3_api_locals_dict, ev3_api_locals_dict_table);
+static MP_DEFINE_CONST_DICT(ev3_api_locals_dict, ev3_api_locals_dict_table);
 
 MP_DEFINE_CONST_OBJ_TYPE(
     ev3_api,
@@ -348,14 +350,14 @@ MP_DEFINE_CONST_OBJ_TYPE(
     locals_dict, &ev3_api_locals_dict
 );
 
-STATIC const mp_rom_map_elem_t ev3_module_globals_table[] = {
+static const mp_rom_map_elem_t ev3_module_globals_table[] = {
     {MP_ROM_QSTR(MP_QSTR___name__),             MP_ROM_QSTR(MP_QSTR_ev3_sensor_ll)},
     {MP_ROM_QSTR(MP_QSTR_EV3Sensor),            MP_ROM_PTR(&ev3_api)},
     {MP_ROM_QSTR(MP_QSTR_SensorNotReadyError),  MP_ROM_PTR(&mp_type_SensorNotReadyError)},
     {MP_ROM_QSTR(MP_QSTR_PortAlreadyOpenError), MP_ROM_PTR(&mp_type_PortAlreadyOpenError)},
     {MP_ROM_QSTR(MP_QSTR_SensorMismatchError),  MP_ROM_PTR(&mp_type_SensorMismatchError)},
 };
-STATIC MP_DEFINE_CONST_DICT(ev3_module_globals, ev3_module_globals_table);
+static MP_DEFINE_CONST_DICT(ev3_module_globals, ev3_module_globals_table);
 
 const mp_obj_module_t ev3_module = {
     .base = {&mp_type_module},

micropython/modules/jv_motors/jv_motor_api.c

@@ -31,7 +31,7 @@ static motor_obj_t *to_initialized_motor(mp_obj_t obj) {
   return self;
 }
 
-STATIC mp_obj_t motor_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+static mp_obj_t motor_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
   enum {
     ARG_port, ARG_type, ARG_positive_direction
   };
@@ -64,7 +64,7 @@ STATIC mp_obj_t motor_make_new(const mp_obj_type_t *type, size_t n_args, size_t
     mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Unknown motor direction %d"), mdir);
   }
 
-  motor_obj_t *obj = m_new_obj_with_finaliser(motor_obj_t);
+  motor_obj_t *obj = mp_obj_malloc_with_finaliser(motor_obj_t, &motor_type);
   obj->base.type = type;
   if (!reg_motor_init(&obj->motor, port, mtype, mdir == DIRECTION_CLOCKWISE)) {
     m_del_obj(motor_obj_t, obj);
@@ -79,7 +79,7 @@ static void motor_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind
   mp_printf(print, "Motor(MOTOR_PORT%d)", self->motor.encoder.port + 1);
 }
 
-STATIC mp_obj_t motor_finalizer(mp_obj_t self_in) {
+static mp_obj_t motor_finalizer(mp_obj_t self_in) {
   motor_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
   if (self->initialized) {
@@ -89,17 +89,17 @@ STATIC mp_obj_t motor_finalizer(mp_obj_t self_in) {
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(motor_finalizer_obj, motor_finalizer);
+static MP_DEFINE_CONST_FUN_OBJ_1(motor_finalizer_obj, motor_finalizer);
 
-STATIC mp_obj_t motor_angle(mp_obj_t self_in) {
+static mp_obj_t motor_angle(mp_obj_t self_in) {
   motor_obj_t *self = to_initialized_motor(self_in);
 
   return mp_obj_new_int(reg_motor_get_angle(&self->motor));
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(motor_angle_obj, motor_angle);
+static MP_DEFINE_CONST_FUN_OBJ_1(motor_angle_obj, motor_angle);
 
-STATIC mp_obj_t motor_reset_angle(size_t n, const mp_obj_t *objs) {
+static mp_obj_t motor_reset_angle(size_t n, const mp_obj_t *objs) {
   motor_obj_t *self = to_initialized_motor(objs[0]);
 
   int32_t new_angle = 0;
@@ -111,25 +111,25 @@ STATIC mp_obj_t motor_reset_angle(size_t n, const mp_obj_t *objs) {
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(motor_reset_angle_obj, 1, 2, motor_reset_angle);
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(motor_reset_angle_obj, 1, 2, motor_reset_angle);
 
-STATIC mp_obj_t motor_speed(mp_obj_t self_in) {
+static mp_obj_t motor_speed(mp_obj_t self_in) {
   motor_obj_t *self = to_initialized_motor(self_in);
 
   return mp_obj_new_int(reg_motor_get_speed(&self->motor));
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(motor_speed_obj, motor_speed);
+static MP_DEFINE_CONST_FUN_OBJ_1(motor_speed_obj, motor_speed);
 
-STATIC mp_obj_t motor_get_cur_power(mp_obj_t self_in) {
+static mp_obj_t motor_get_cur_power(mp_obj_t self_in) {
   motor_obj_t *self = to_initialized_motor(self_in);
 
   return mp_obj_new_int(reg_motor_get_current_power(&self->motor));
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(motor_get_cur_power_obj, motor_get_cur_power);
+static MP_DEFINE_CONST_FUN_OBJ_1(motor_get_cur_power_obj, motor_get_cur_power);
 
-STATIC mp_obj_t motor_attr(mp_obj_t self_in, qstr attribute, mp_obj_t *dest) {
+static mp_obj_t motor_attr(mp_obj_t self_in, qstr attribute, mp_obj_t *dest) {
   if (dest[0] == MP_OBJ_SENTINEL && dest[1] == MP_OBJ_NULL) {
     mp_raise_msg(&mp_type_NotImplementedError, MP_ERROR_TEXT("attribute deletion not supported"));
   }
@@ -251,24 +251,24 @@ STATIC mp_obj_t motor_attr(mp_obj_t self_in, qstr attribute, mp_obj_t *dest) {
 }
 
 
-STATIC mp_obj_t motor_is_complete(mp_obj_t self_in) {
+static mp_obj_t motor_is_complete(mp_obj_t self_in) {
   motor_obj_t *self = to_initialized_motor(self_in);
 
   return mp_obj_new_bool(reg_motor_is_complete(&self->motor));
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(motor_is_complete_obj, motor_is_complete);
+static MP_DEFINE_CONST_FUN_OBJ_1(motor_is_complete_obj, motor_is_complete);
 
-STATIC mp_obj_t motor_wait_complete(mp_obj_t self_in) {
+static mp_obj_t motor_wait_complete(mp_obj_t self_in) {
   motor_obj_t *self = to_initialized_motor(self_in);
 
   reg_motor_wait_complete(&self->motor);
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(motor_wait_complete_obj, motor_wait_complete);
+static MP_DEFINE_CONST_FUN_OBJ_1(motor_wait_complete_obj, motor_wait_complete);
 
-STATIC mp_obj_t motor_coast(mp_obj_t self_in) {
+static mp_obj_t motor_coast(mp_obj_t self_in) {
   motor_obj_t *self = to_initialized_motor(self_in);
 
   if (!reg_motor_coast(&self->motor)) {
@@ -278,9 +278,9 @@ STATIC mp_obj_t motor_coast(mp_obj_t self_in) {
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(motor_coast_obj, motor_coast);
+static MP_DEFINE_CONST_FUN_OBJ_1(motor_coast_obj, motor_coast);
 
-STATIC mp_obj_t motor_brake(mp_obj_t self_in) {
+static mp_obj_t motor_brake(mp_obj_t self_in) {
   motor_obj_t *self = to_initialized_motor(self_in);
 
   if (!reg_motor_brake(&self->motor)) {
@@ -290,19 +290,19 @@ STATIC mp_obj_t motor_brake(mp_obj_t self_in) {
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(motor_brake_obj, motor_brake);
+static MP_DEFINE_CONST_FUN_OBJ_1(motor_brake_obj, motor_brake);
 
-STATIC mp_obj_t motor_hold(mp_obj_t self_in) {
+static mp_obj_t motor_hold(mp_obj_t self_in) {
   motor_obj_t *self = to_initialized_motor(self_in);
 
   reg_motor_hold(&self->motor);
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(motor_hold_obj, motor_hold);
+static MP_DEFINE_CONST_FUN_OBJ_1(motor_hold_obj, motor_hold);
 
 
-STATIC mp_obj_t motor_run_unregulated(mp_obj_t self_in, mp_obj_t power) {
+static mp_obj_t motor_run_unregulated(mp_obj_t self_in, mp_obj_t power) {
   motor_obj_t *self = to_initialized_motor(self_in);
 
   if (!reg_motor_run_unregulated(&self->motor, mp_obj_get_int(power))) {
@@ -312,10 +312,10 @@ STATIC mp_obj_t motor_run_unregulated(mp_obj_t self_in, mp_obj_t power) {
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(motor_run_unregulated_obj, motor_run_unregulated);
+static MP_DEFINE_CONST_FUN_OBJ_2(motor_run_unregulated_obj, motor_run_unregulated);
 
 
-STATIC mp_obj_t motor_run_to_angle(size_t n, const mp_obj_t *pos, mp_map_t *kws) {
+static mp_obj_t motor_run_to_angle(size_t n, const mp_obj_t *pos, mp_map_t *kws) {
   enum {
     ARG_speed,
     ARG_target_angle,
@@ -346,9 +346,9 @@ STATIC mp_obj_t motor_run_to_angle(size_t n, const mp_obj_t *pos, mp_map_t *kws)
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(motor_run_to_angle_obj, 3, motor_run_to_angle);
+static MP_DEFINE_CONST_FUN_OBJ_KW(motor_run_to_angle_obj, 3, motor_run_to_angle);
 
-STATIC mp_obj_t motor_run_by_angle(size_t n, const mp_obj_t *pos, mp_map_t *kws) {
+static mp_obj_t motor_run_by_angle(size_t n, const mp_obj_t *pos, mp_map_t *kws) {
   enum {
     ARG_speed, ARG_rotation_angle, ARG_then, ARG_wait
   };
@@ -376,9 +376,9 @@ STATIC mp_obj_t motor_run_by_angle(size_t n, const mp_obj_t *pos, mp_map_t *kws)
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(motor_run_by_angle_obj, 3, motor_run_by_angle);
+static MP_DEFINE_CONST_FUN_OBJ_KW(motor_run_by_angle_obj, 3, motor_run_by_angle);
 
-STATIC mp_obj_t motor_run_timed(size_t n, const mp_obj_t *pos, mp_map_t *kws) {
+static mp_obj_t motor_run_timed(size_t n, const mp_obj_t *pos, mp_map_t *kws) {
   enum {
     ARG_speed, ARG_time, ARG_then, ARG_wait
   };
@@ -406,9 +406,9 @@ STATIC mp_obj_t motor_run_timed(size_t n, const mp_obj_t *pos, mp_map_t *kws) {
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(motor_run_timed_obj, 3, motor_run_timed);
+static MP_DEFINE_CONST_FUN_OBJ_KW(motor_run_timed_obj, 3, motor_run_timed);
 
-STATIC mp_obj_t motor_run_ext_ref(size_t n, const mp_obj_t *pos, mp_map_t *kws) {
+static mp_obj_t motor_run_ext_ref(size_t n, const mp_obj_t *pos, mp_map_t *kws) {
   enum {
     ARG_target_angle,
     ARG_target_speed,
@@ -438,19 +438,19 @@ STATIC mp_obj_t motor_run_ext_ref(size_t n, const mp_obj_t *pos, mp_map_t *kws)
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(motor_run_ext_ref_obj, 2, motor_run_ext_ref);
+static MP_DEFINE_CONST_FUN_OBJ_KW(motor_run_ext_ref_obj, 2, motor_run_ext_ref);
 
-STATIC mp_obj_t motor_run_unlimited(mp_obj_t self_in, mp_obj_t speed) {
+static mp_obj_t motor_run_unlimited(mp_obj_t self_in, mp_obj_t speed) {
   motor_obj_t *self = to_initialized_motor(self_in);
 
   reg_motor_run_unlimited(&self->motor, mp_obj_get_float_to_f(speed));
   return mp_const_none;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(motor_run_unlimited_obj, motor_run_unlimited);
+static MP_DEFINE_CONST_FUN_OBJ_2(motor_run_unlimited_obj, motor_run_unlimited);
 
 
-STATIC const mp_rom_map_elem_t motor_dict_table[] = {
+static const mp_rom_map_elem_t motor_dict_table[] = {
     // lifetime management
     {MP_ROM_QSTR(MP_QSTR___del__),          MP_ROM_PTR(&motor_finalizer_obj)},
     {MP_ROM_QSTR(MP_QSTR_close),            MP_ROM_PTR(&motor_finalizer_obj)},
@@ -489,7 +489,7 @@ STATIC const mp_rom_map_elem_t motor_dict_table[] = {
     {MP_ROM_QSTR(MP_QSTR_CLOCKWISE),        MP_ROM_INT(DIRECTION_CLOCKWISE)},
     {MP_ROM_QSTR(MP_QSTR_COUNTERCLOCKWISE), MP_ROM_INT(DIRECTION_COUNTERCLOCKWISE)},
 };
-STATIC MP_DEFINE_CONST_DICT(motor_dict, motor_dict_table);
+static MP_DEFINE_CONST_DICT(motor_dict, motor_dict_table);
 
 
 MP_DEFINE_CONST_OBJ_TYPE(
@@ -502,11 +502,11 @@ MP_DEFINE_CONST_OBJ_TYPE(
     print, &motor_print
 );
 
-STATIC const mp_rom_map_elem_t jv_motors_module_globals_table[] = {
+static const mp_rom_map_elem_t jv_motors_module_globals_table[] = {
     {MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_jv_motors)},
     {MP_ROM_QSTR(MP_QSTR_Motor),    MP_ROM_PTR(&motor_type)},
 };
-STATIC MP_DEFINE_CONST_DICT(jv_motors_module_globals, jv_motors_module_globals_table);
+static MP_DEFINE_CONST_DICT(jv_motors_module_globals, jv_motors_module_globals_table);
 
 const mp_obj_module_t jv_motors_module = {
     .base = {&mp_type_module},

micropython/modules/lib/i2c_master.c

-#include "hardware/i2c.h"
-
-#include "PCF8575.h"
-#include <opencube_hw.h>
-
-void opencube_i2c_master_init() {
-    PCF8575_init();
-    PCF8575_write_pin(I2C_STRONG_PULL_RPIN, false); // activate external pull-ups
-
-    gpio_init(UTZ_I2C_SDA_PIN);
-    gpio_set_function(UTZ_I2C_SDA_PIN, GPIO_FUNC_I2C);
-
-    gpio_init(UTZ_I2C_SCK_PIN);
-    gpio_set_function(UTZ_I2C_SCK_PIN, GPIO_FUNC_I2C);
-
-    i2c_init(UTZ_I2C_BUS, MULTICUBE_I2C_BAUD_RATE);
-}
-
-// I2C reserves some addresses for special purposes. We exclude these from the scan.
-// These are any addresses of the form 000 0xxx or 111 1xxx
-bool reserved_addr(uint8_t addr) {
-    return (addr & 0x78) == 0 || (addr & 0x78) == 0x78;
-}
\ No newline at end of file

micropython/modules/lib/i2c_master.h

-/**
- *  Library for I2C master multicube communication
- */
-#ifndef OPENCUBE_I2C_MASTER_H
-#define OPENCUBE_I2C_MASTER_H
-
-#endif //OPENCUBE_I2C_MASTER_H
\ No newline at end of file

micropython/modules/lib/i2c_slave.c

-#include <hardware/i2c.h>
-#include "pico/i2c_slave.h"
-
-#include <opencube_hw.h>
-
-// The slave implements a 256 byte memory. To write a series of bytes, the master first
-// writes the memory address, followed by the data. The address is automatically incremented
-// for each byte transferred, looping back to 0 upon reaching the end. Reading is done
-// sequentially from the current memory address.
-static struct
-{
-    uint8_t mem[256];
-    uint8_t mem_address;
-    bool mem_address_written;
-} context;
-
-static void opencube_i2c_slave_handler(i2c_inst_t *i2c, i2c_slave_event_t event);
-
-// Our handler is called from the I2C ISR, so it must complete quickly. Blocking calls /
-// printing to stdio may interfere with interrupt handling.
-static void opencube_i2c_slave_handler(i2c_inst_t *i2c, i2c_slave_event_t event) {
-    switch (event) {
-    case I2C_SLAVE_RECEIVE: // master has written some data
-        if (!context.mem_address_written) {
-            // writes always start with the memory address
-            context.mem_address = i2c_read_byte_raw(i2c);
-            context.mem_address_written = true;
-        } else {
-            // save into memory
-            context.mem[context.mem_address] = i2c_read_byte_raw(i2c);
-            context.mem_address++;
-        }
-        break;
-    case I2C_SLAVE_REQUEST: // master is requesting data
-        // load from memory
-        i2c_write_byte_raw(i2c, context.mem[context.mem_address]);
-        context.mem_address++;
-        break;
-    case I2C_SLAVE_FINISH: // master has signalled Stop / Restart
-        context.mem_address_written = false;
-        break;
-    default:
-        break;
-    }
-}
-
-void opencube_i2c_slave_init(uint8_t address) {
-    PCF8575_init();
-    PCF8575_write_pin(I2C_STRONG_PULL_RPIN, true)
-
-    gpio_init(UTZ_I2C_SDA_PIN);
-    gpio_set_function(UTZ_I2C_SDA_PIN, GPIO_FUNC_I2C);
-
-    gpio_init(UTZ_I2C_SCK_PIN);
-    gpio_set_function(UTZ_I2C_SCK_PIN, GPIO_FUNC_I2C);
-
-    i2c_init(UTZ_I2C_BUS, MULTICUBE_I2C_BAUD_RATE);
-    // configure for slave mode
-    i2c_slave_init(i2c0, address, &opencube_i2c_slave_handler);
-}
-
-// I2C reserves some addresses for special purposes. We exclude these from the scan.
-// These are any addresses of the form 000 0xxx or 111 1xxx
-bool reserved_addr(uint8_t addr) {
-    return (addr & 0x78) == 0 || (addr & 0x78) == 0x78;
-}
\ No newline at end of file

micropython/modules/lib/i2c_slave.h

-/**
- *  Library for I2C slave multicube communication
- */
-#ifndef OPENCUBE_I2C_SLAVE_H
-#define OPENCUBE_I2C_SLAVE_H
-
-#endif //OPENCUBE_I2C_SLAVE_H
\ No newline at end of file

micropython/modules/nxt_sensors/analog_sensor.c

@@ -32,7 +32,7 @@ typedef struct {
     analog_port ports[NUM_SENSOR_PORTS];
     alarm_pool_t *timer_pool;
     repeating_timer_t timer;
-    ADS1119_adc_t *adc;
+    ADS1119_adc_t adc;
     bool continuous;
     uint8_t continuous_state;
     uint8_t current_port;
@@ -78,13 +78,11 @@ void opencube_analog_sensors_init(void) {
         }
     }
 
-    ADS1119_adc_t *adc = (ADS1119_adc_t*)malloc(sizeof(ADS1119_adc_t));
-    sensors.adc = adc;
     opencube_lock_i2c_or_raise();
-    ADS1119_init(sensors.adc);
-    ADS1119_set_vref(sensors.adc, 1);
-    ADS1119_set_data_rate(sensors.adc, 3);
-    ADS1119_write_config(sensors.adc);
+    ADS1119_init(&sensors.adc);
+    ADS1119_set_vref(&sensors.adc, 1);
+    ADS1119_set_data_rate(&sensors.adc, 3);
+    ADS1119_write_config(&sensors.adc);
     opencube_unlock_i2c();
     sensors.current_port = 255;
     sensors.enabled = true;
@@ -113,7 +111,6 @@ void opencube_analog_sensors_deinit(void) {
     {
 		opencube_analog_sensor_deinit(i);
 	}
-    sensors.adc = NULL;
     sensors.enabled = false;
 }
 
@@ -161,8 +158,8 @@ void opencube_analog_sensor_set_switching(uint8_t port, bool switching) {
 
 void opencube_analog_sensor_set_channel(uint8_t port) {
     if (sensors.ports[port].enabled) {
-        ADS1119_set_channel(sensors.adc, sensors.ports[port].channel);
-        ADS1119_write_config(sensors.adc);
+        ADS1119_set_channel(&sensors.adc, sensors.ports[port].channel);
+        ADS1119_write_config(&sensors.adc);
         sensors.current_port = port;
     }
 }
@@ -176,7 +173,7 @@ void opencube_analog_sensor_read_value(uint8_t port) {
             opencube_unlock_i2c();
         }
         // blocking ADC value read
-        uint16_t value = ADS1119_lockBusAndReadTwoBytes(sensors.adc);
+        uint16_t value = ADS1119_lockBusAndReadTwoBytes(&sensors.adc);
         // if in switching mode update value depending on led state
         if (sensors.ports[port].switching) {
             if (sensors.ports[port].pin_state) {
@@ -274,7 +271,7 @@ bool opencube_analog_sensor_continuous(repeating_timer_t *timer) {
         return true;
     }
 
-    uint16_t value = ADS1119_read(sensors.adc);
+    uint16_t value = ADS1119_read(&sensors.adc);
     sensors.ports[sensors.current_port].scanned = true;
 
     // in switching mode save read value to desired variable
@@ -326,7 +323,7 @@ bool opencube_analog_sensor_continuous(repeating_timer_t *timer) {
     // Switch to a different adc channel and start new conversion
     if (start_next_read) {
         opencube_analog_sensor_set_channel(sensors.current_port);
-        ADS1119_commandStart(sensors.adc);
+        ADS1119_commandStart(&sensors.adc);
     }
 
     opencube_unlock_i2c();

micropython/modules/nxt_sensors/analog_sensor_api.c

@@ -12,15 +12,17 @@ typedef struct _analog_sensor_obj_t {
     uint8_t port;
 } analog_sensor_obj_t;
 
+const mp_obj_type_t opencube_analog_sensor;
+
 // Called on AnalogSensor init
 // Initialize AnalogSensor on given port
-STATIC mp_obj_t analog_sensor_make_new(const mp_obj_type_t* type, size_t n_args, size_t n_kw, const mp_obj_t* args) {
+static mp_obj_t analog_sensor_make_new(const mp_obj_type_t* type, size_t n_args, size_t n_kw, const mp_obj_t* args) {
     mp_arg_check_num(n_args, n_kw, 1, 1, false);
     int port = mp_obj_get_int(args[0]);
     if (port < 0 || port > 3) {
         mp_raise_msg_varg(&mp_type_ValueError, "Port %d is not a valid sensor port", port+1);
     }
-    analog_sensor_obj_t *self = m_new_obj_with_finaliser(analog_sensor_obj_t);
+    analog_sensor_obj_t *self = mp_obj_malloc_with_finaliser(analog_sensor_obj_t, &opencube_analog_sensor);
 
     self->port = port;
     self->base.type = type;
@@ -36,93 +38,93 @@ static void analog_sensor_print(const mp_print_t *print, mp_obj_t self_in) {
 }
 
 // Turn on output pin
-STATIC mp_obj_t analog_sensor_on(mp_obj_t self_in) {
+static mp_obj_t analog_sensor_on(mp_obj_t self_in) {
     analog_sensor_obj_t *self = MP_OBJ_TO_PTR(self_in);
     opencube_analog_sensor_turn_on(self->port);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_on_obj, analog_sensor_on);
+static MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_on_obj, analog_sensor_on);
 
 // Turn off output pin
-STATIC mp_obj_t analog_sensor_off(mp_obj_t self_in) {
+static mp_obj_t analog_sensor_off(mp_obj_t self_in) {
     analog_sensor_obj_t *self = MP_OBJ_TO_PTR(self_in);
     opencube_analog_sensor_turn_off(self->port);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_off_obj, analog_sensor_off);
+static MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_off_obj, analog_sensor_off);
 
 // Toggle output pin 
-STATIC mp_obj_t analog_sensor_toggle(mp_obj_t self_in) {
+static mp_obj_t analog_sensor_toggle(mp_obj_t self_in) {
     analog_sensor_obj_t *self = MP_OBJ_TO_PTR(self_in);
     opencube_analog_sensor_toggle(self->port);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_toggle_obj, analog_sensor_toggle);
+static MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_toggle_obj, analog_sensor_toggle);
 
 // In normal mode - measure and return analog value
 // In continuous mode - return last measured analog value
 // If pin_on is True - last value when output pin was on, False - last value when output pin was off
-STATIC mp_obj_t analog_sensor_get_value(mp_obj_t self_in, mp_obj_t pin_on) {
+static mp_obj_t analog_sensor_get_value(mp_obj_t self_in, mp_obj_t pin_on) {
     analog_sensor_obj_t *self = MP_OBJ_TO_PTR(self_in);
     bool on = (mp_obj_get_int(pin_on) == 1);
 
     uint16_t value = opencube_analog_sensor_get_value(self->port, on);
     return mp_obj_new_int(value);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(analog_sensor_get_value_obj, analog_sensor_get_value);
+static MP_DEFINE_CONST_FUN_OBJ_2(analog_sensor_get_value_obj, analog_sensor_get_value);
 
 // Check if new data is available
-STATIC mp_obj_t analog_sensor_new_data(mp_obj_t self_in, mp_obj_t led_on) {
+static mp_obj_t analog_sensor_new_data(mp_obj_t self_in, mp_obj_t led_on) {
     analog_sensor_obj_t *self = MP_OBJ_TO_PTR(self_in);
     bool led_on_bool = (mp_obj_get_int(led_on) == 1);
     return mp_obj_new_int(opencube_analog_sensor_new_data(self->port, led_on_bool));
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(analog_sensor_new_data_obj, analog_sensor_new_data);
+static MP_DEFINE_CONST_FUN_OBJ_2(analog_sensor_new_data_obj, analog_sensor_new_data);
 
 // Set sensor port switching mode for continuous measurement.
 // Output value is measured automaticaly with the output pin on and with the output pin off
-STATIC mp_obj_t analog_sensor_set_switching(mp_obj_t self_in) {
+static mp_obj_t analog_sensor_set_switching(mp_obj_t self_in) {
     analog_sensor_obj_t *self = MP_OBJ_TO_PTR(self_in);
     opencube_analog_sensor_set_switching(self->port, true);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_set_switching_obj, analog_sensor_set_switching);
+static MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_set_switching_obj, analog_sensor_set_switching);
 
 // Set sensor port to non-switching mode for continuous measurement.
-STATIC mp_obj_t analog_sensor_stop_switching(mp_obj_t self_in) {
+static mp_obj_t analog_sensor_stop_switching(mp_obj_t self_in) {
     analog_sensor_obj_t *self = MP_OBJ_TO_PTR(self_in);
     opencube_analog_sensor_set_switching(self->port, false);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_stop_switching_obj, analog_sensor_stop_switching);
+static MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_stop_switching_obj, analog_sensor_stop_switching);
 
 // Set all analog sensors to continuous mode with given period (us)
 // Wait given time (us) after switching output pin state in switching mode 
-STATIC mp_obj_t analog_sensor_set_continuous(mp_obj_t self_in, mp_obj_t period_us, mp_obj_t wait_us) {
+static mp_obj_t analog_sensor_set_continuous(mp_obj_t self_in, mp_obj_t period_us, mp_obj_t wait_us) {
     uint32_t period = mp_obj_get_int(period_us);
     uint32_t wait = mp_obj_get_int(wait_us);
     opencube_analog_sensor_start_continuous(period, wait);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(analog_sensor_set_continuous_obj, analog_sensor_set_continuous);
+static MP_DEFINE_CONST_FUN_OBJ_3(analog_sensor_set_continuous_obj, analog_sensor_set_continuous);
 
 // Stop continuous measurement of all analog sensors
-STATIC mp_obj_t analog_sensor_stop_continuous(mp_obj_t self_in) {
+static mp_obj_t analog_sensor_stop_continuous(mp_obj_t self_in) {
     opencube_analog_sensor_stop_continuous();
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_stop_continuous_obj, analog_sensor_stop_continuous);
+static MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_stop_continuous_obj, analog_sensor_stop_continuous);
 
 // Deinitialize analog sensor
-STATIC mp_obj_t analog_sensor_deinit(mp_obj_t self_in) {
+static mp_obj_t analog_sensor_deinit(mp_obj_t self_in) {
     analog_sensor_obj_t *self = MP_OBJ_TO_PTR(self_in);
     opencube_analog_sensor_deinit(self->port);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_deinit_obj, analog_sensor_deinit);
+static MP_DEFINE_CONST_FUN_OBJ_1(analog_sensor_deinit_obj, analog_sensor_deinit);
 
 // This collects all methods and other static class attributes of the AnalogSensor.
-STATIC const mp_rom_map_elem_t analog_sensor_locals_dict[] = {
+static const mp_rom_map_elem_t analog_sensor_locals_dict[] = {
     { MP_ROM_QSTR(MP_QSTR_on), MP_ROM_PTR(&analog_sensor_on_obj) },
     { MP_ROM_QSTR(MP_QSTR_off), MP_ROM_PTR(&analog_sensor_off_obj) },
     { MP_ROM_QSTR(MP_QSTR_toggle), MP_ROM_PTR(&analog_sensor_toggle_obj) },
@@ -133,8 +135,9 @@ STATIC const mp_rom_map_elem_t analog_sensor_locals_dict[] = {
     { MP_ROM_QSTR(MP_QSTR_set_continuous), MP_ROM_PTR(&analog_sensor_set_continuous_obj) },
     { MP_ROM_QSTR(MP_QSTR_stop_continuous), MP_ROM_PTR(&analog_sensor_stop_continuous_obj)},
     { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&analog_sensor_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&analog_sensor_deinit_obj) },
 };
-STATIC MP_DEFINE_CONST_DICT(analog_sensor_locals_dict_obj, analog_sensor_locals_dict);
+static MP_DEFINE_CONST_DICT(analog_sensor_locals_dict_obj, analog_sensor_locals_dict);
 
 // This defines the type(AnalogSensor) object.
 MP_DEFINE_CONST_OBJ_TYPE(
@@ -151,16 +154,16 @@ MP_DEFINE_CONST_OBJ_TYPE(
 // and the MicroPython object reference.
 // All identifiers and strings are written as MP_QSTR_xxx and will be
 // optimized to word-sized integers by the build system (interned strings).
-STATIC const mp_rom_map_elem_t analog_sensor_globals_dict[] = {
+static const mp_rom_map_elem_t analog_sensor_globals_dict[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_analog_sensor) },
     { MP_ROM_QSTR(MP_QSTR_AnalogSensor), MP_ROM_PTR(&opencube_analog_sensor) },
 };
-STATIC MP_DEFINE_CONST_DICT(analog_sensor_globals_dict_obj, analog_sensor_globals_dict);
+static MP_DEFINE_CONST_DICT(analog_sensor_globals_dict_obj, analog_sensor_globals_dict);
 
 // Define module object.
 const mp_obj_module_t analog_sensor = {
     .base = {.type = &mp_type_module },
-    .globals = (mp_obj_dict_t*)&analog_sensor_globals_dict_obj,
+    .globals = (mp_obj_dict_t *) &analog_sensor_globals_dict_obj,
 };
 
 // Register the module to make it available in Python.

micropython/modules/opencube_brick/ICM_api.c

@@ -9,19 +9,20 @@
 // This structure represents ICM instance objects.
 typedef struct _ICM_obj_t {
     mp_obj_base_t base;
-    ICM42688_t* icm;
+    ICM42688_t icm;
 } ICM_obj_t;
 
+const mp_obj_type_t opencube_ICM_type;
 
 static void ICM_print(const mp_print_t *print, mp_obj_t self_in);
 
 // Called on ICM init
-STATIC mp_obj_t ICM_make_new(const mp_obj_type_t* type, size_t n_args, size_t n_kw, const mp_obj_t* args) {
-    ICM_obj_t *self = m_new_obj(ICM_obj_t);	
+static mp_obj_t ICM_make_new(const mp_obj_type_t* type, size_t n_args, size_t n_kw, const mp_obj_t* args) {
+    ICM_obj_t *self = mp_obj_malloc_with_finaliser(ICM_obj_t, &opencube_ICM_type);
     self->base.type = type;
-    self->icm = (ICM42688_t*)malloc(sizeof(ICM42688_t));
+    //self->icm = (ICM42688_t*)malloc(sizeof(ICM42688_t));
     opencube_lock_i2c_or_raise();
-    ICM42688_init(self->icm);
+    ICM42688_init(&self->icm);
     opencube_unlock_i2c();
     return MP_OBJ_FROM_PTR(self);
 }
@@ -30,11 +31,11 @@ static void ICM_print(const mp_print_t *print, mp_obj_t self_in) {
     //ICM_obj_t *self = MP_OBJ_TO_PTR(self_in);
 }
 
-STATIC mp_obj_t ICM_read_value(mp_obj_t self_in) {
+static mp_obj_t ICM_read_value(mp_obj_t self_in) {
     ICM_obj_t *self = MP_OBJ_TO_PTR(self_in);	
     float accel_x, accel_y, accel_z, gyro_x, gyro_y, gyro_z;
     opencube_lock_i2c_or_raise();
-    ICM42688_read_data(self->icm, 
+    ICM42688_read_data(&self->icm, 
                        &accel_x, &accel_y, &accel_z, 
                        &gyro_x, &gyro_y, &gyro_z);
     opencube_unlock_i2c();
@@ -48,25 +49,25 @@ STATIC mp_obj_t ICM_read_value(mp_obj_t self_in) {
         };
     return mp_obj_new_tuple(6, tuple);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(ICM_read_value_obj, ICM_read_value);
+static MP_DEFINE_CONST_FUN_OBJ_1(ICM_read_value_obj, ICM_read_value);
 
 static mp_obj_t ICM_deinit(mp_obj_t self_in) {
     ICM_obj_t *self = MP_OBJ_FROM_PTR(self_in);
-    ICM42688_off(self->icm);
-    self->icm = NULL;
+    ICM42688_off(&self->icm);
+    //self->icm = NULL;
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(ICM_deinit_obj, ICM_deinit);
+static MP_DEFINE_CONST_FUN_OBJ_1(ICM_deinit_obj, ICM_deinit);
 
 // This collects all methods and other static class attributes of the ICM.
 // The table structure is similar to the module table, as detailed below.
-STATIC const mp_rom_map_elem_t ICM_locals_dict[] = {
+static const mp_rom_map_elem_t ICM_locals_dict[] = {
     { MP_ROM_QSTR(MP_QSTR_read_value), MP_ROM_PTR(&ICM_read_value_obj) },
     { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&ICM_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&ICM_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&ICM_deinit_obj) },
 };
-STATIC MP_DEFINE_CONST_DICT(ICM_locals_dict_obj, ICM_locals_dict);
+static MP_DEFINE_CONST_DICT(ICM_locals_dict_obj, ICM_locals_dict);
 
 // This defines the type(ICM) object.
 MP_DEFINE_CONST_OBJ_TYPE(

micropython/modules/opencube_brick/battery.c

@@ -15,6 +15,8 @@ typedef struct {
     repeating_timer_t timer;
 } battery_obj_t;
 
+const mp_obj_type_t opencube_battery_type;
+
 static void read_voltage(battery_obj_t *self);
 static bool read_voltage_handler(repeating_timer_t *timer);
 static void battery_print(const mp_print_t *print, mp_obj_t self_in);
@@ -34,36 +36,36 @@ static void battery_print(const mp_print_t *print, mp_obj_t self_in) {
     //battery_obj_t *self = MP_OBJ_TO_PTR(self_in);
 }
 
-STATIC mp_obj_t battery_read_voltage(mp_obj_t self_in) {
+static mp_obj_t battery_read_voltage(mp_obj_t self_in) {
     battery_obj_t *self = MP_OBJ_TO_PTR(self_in);
     read_voltage(self);
     return mp_obj_new_float(self->last_value);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(battery_read_voltage_obj, battery_read_voltage);
+static MP_DEFINE_CONST_FUN_OBJ_1(battery_read_voltage_obj, battery_read_voltage);
 
-STATIC mp_obj_t battery_voltage(mp_obj_t self_in) {
+static mp_obj_t battery_voltage(mp_obj_t self_in) {
     battery_obj_t *self = MP_OBJ_TO_PTR(self_in);
     return mp_obj_new_float(self->last_value);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(battery_voltage_obj, battery_voltage);
+static MP_DEFINE_CONST_FUN_OBJ_1(battery_voltage_obj, battery_voltage);
 
-STATIC mp_obj_t battery_set_multiplier(mp_obj_t self_in, mp_obj_t multiplier) {
+static mp_obj_t battery_set_multiplier(mp_obj_t self_in, mp_obj_t multiplier) {
     battery_obj_t *self = MP_OBJ_TO_PTR(self_in);
     self->multiplier = mp_obj_get_float(multiplier);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(battery_set_multiplier_obj, battery_set_multiplier);
+static MP_DEFINE_CONST_FUN_OBJ_2(battery_set_multiplier_obj, battery_set_multiplier);
 
-STATIC mp_obj_t battery_deinit(mp_obj_t self_in) {
+static mp_obj_t battery_deinit(mp_obj_t self_in) {
     battery_obj_t *self = MP_OBJ_TO_PTR(self_in);
     alarm_pool_cancel_alarm(self->timer_pool, self->timer.alarm_id);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(battery_deinit_obj, battery_deinit);
+static MP_DEFINE_CONST_FUN_OBJ_1(battery_deinit_obj, battery_deinit);
 
 // Called on Battery init
-STATIC mp_obj_t battery_make_new(const mp_obj_type_t* type, size_t n_args, size_t n_kw, const mp_obj_t* args) {
-    battery_obj_t *self = m_new_obj_with_finaliser(battery_obj_t);
+static mp_obj_t battery_make_new(const mp_obj_type_t* type, size_t n_args, size_t n_kw, const mp_obj_t* args) {
+    battery_obj_t *self = mp_obj_malloc_with_finaliser(battery_obj_t, &opencube_battery_type);
     self->base.type = type;
     self->multiplier = 1.0;
     // Initialise the ADC peripheral if it's not already running.
@@ -90,14 +92,14 @@ STATIC mp_obj_t battery_make_new(const mp_obj_type_t* type, size_t n_args, size_
 
 // This collects all methods and other static class attributes of the Battery.
 // The table structure is similar to the module table, as detailed below.
-STATIC const mp_rom_map_elem_t battery_locals_dict[] = {
+static const mp_rom_map_elem_t battery_locals_dict[] = {
     { MP_ROM_QSTR(MP_QSTR_read_voltage), MP_ROM_PTR(&battery_read_voltage_obj) },
     { MP_ROM_QSTR(MP_QSTR_voltage), MP_ROM_PTR(&battery_voltage_obj) },
     { MP_ROM_QSTR(MP_QSTR_set_multiplier), MP_ROM_PTR(&battery_set_multiplier_obj) },
     { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&battery_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&battery_deinit_obj) },
 };
-STATIC MP_DEFINE_CONST_DICT(battery_locals_dict_obj, battery_locals_dict);
+static MP_DEFINE_CONST_DICT(battery_locals_dict_obj, battery_locals_dict);
 
 // This defines the type(Battery) object.
 MP_DEFINE_CONST_OBJ_TYPE(

micropython/modules/opencube_brick/brick_api.c

@@ -7,11 +7,11 @@
 #include "led.h"
 #include "opencube_fw_version.h"
 
-STATIC mp_obj_t i2c_lock_fun(void) {
+static mp_obj_t i2c_lock_fun(void) {
     opencube_lock_i2c_or_raise();
     return mp_const_none;
 }
-STATIC mp_obj_t i2c_unlock_fun(void) {
+static mp_obj_t i2c_unlock_fun(void) {
     opencube_unlock_i2c();
     return mp_const_none;
 }

micropython/modules/opencube_brick/buttons.c

@@ -21,7 +21,7 @@ typedef struct _buttons_obj_t {
 //static void pcf_irq_handler(void);
 
 // Called on buttons init
-STATIC mp_obj_t buttons_make_new(const mp_obj_type_t* type, size_t n_args, size_t n_kw, const mp_obj_t* args) {
+static mp_obj_t buttons_make_new(const mp_obj_type_t* type, size_t n_args, size_t n_kw, const mp_obj_t* args) {
     buttons_obj_t *self = m_new_obj(buttons_obj_t);
     self->base.type = type;
     opencube_lock_i2c_or_raise();
@@ -30,11 +30,11 @@ STATIC mp_obj_t buttons_make_new(const mp_obj_type_t* type, size_t n_args, size_
     return MP_OBJ_FROM_PTR(self);
 }
 
-STATIC void buttons_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+static void buttons_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
   mp_printf(print, "Buttons");
 }
 
-STATIC mp_obj_t buttons_pressed(mp_obj_t self_in) {
+static mp_obj_t buttons_pressed(mp_obj_t self_in) {
     uint16_t pcf_last_read = PCF8575_read_value();
     uint16_t pcf_last_write = PCF8575_read_function();
     mp_obj_t tuple[6] = {
@@ -48,9 +48,9 @@ STATIC mp_obj_t buttons_pressed(mp_obj_t self_in) {
         };
     return mp_obj_new_tuple(6, tuple);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(buttons_pressed_obj, buttons_pressed);
+static MP_DEFINE_CONST_FUN_OBJ_1(buttons_pressed_obj, buttons_pressed);
 
-STATIC mp_obj_t buttons_pressed_since(mp_obj_t self_in) {
+static mp_obj_t buttons_pressed_since(mp_obj_t self_in) {
     uint16_t pcf_last_read = PCF8575_read_value_missed();
     mp_obj_t tuple[6] = {
             tuple[0] = mp_obj_new_bool(0),
@@ -62,9 +62,9 @@ STATIC mp_obj_t buttons_pressed_since(mp_obj_t self_in) {
         };
     return mp_obj_new_tuple(6, tuple);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(buttons_pressed_since_obj, buttons_pressed_since);
+static MP_DEFINE_CONST_FUN_OBJ_1(buttons_pressed_since_obj, buttons_pressed_since);
 
-STATIC mp_obj_t buttons_read_value(mp_obj_t self_in) {
+static mp_obj_t buttons_read_value(mp_obj_t self_in) {
     if (opencube_try_lock_i2c())
     {
         PCF8575_read();
@@ -72,9 +72,9 @@ STATIC mp_obj_t buttons_read_value(mp_obj_t self_in) {
     }
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(buttons_read_value_obj, buttons_read_value);
+static MP_DEFINE_CONST_FUN_OBJ_1(buttons_read_value_obj, buttons_read_value);
 
-STATIC mp_obj_t buttons_set_pin(mp_obj_t self_in, mp_obj_t pin, mp_obj_t value) {
+static mp_obj_t buttons_set_pin(mp_obj_t self_in, mp_obj_t pin, mp_obj_t value) {
     uint8_t pin_num = mp_obj_get_int(pin);
     bool pin_value = mp_obj_get_int(value);
     if (opencube_try_lock_i2c())
@@ -84,24 +84,24 @@ STATIC mp_obj_t buttons_set_pin(mp_obj_t self_in, mp_obj_t pin, mp_obj_t value)
     }
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(buttons_set_pin_obj, buttons_set_pin);
+static MP_DEFINE_CONST_FUN_OBJ_3(buttons_set_pin_obj, buttons_set_pin);
 
-STATIC mp_obj_t buttons_turn_off_cube(mp_obj_t self_in) {
+static mp_obj_t buttons_turn_off_cube(mp_obj_t self_in) {
     gpio_put(TURN_OFF_PIN, true);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(buttons_turn_off_cube_obj, buttons_turn_off_cube);
+static MP_DEFINE_CONST_FUN_OBJ_1(buttons_turn_off_cube_obj, buttons_turn_off_cube);
 
 
 // This collects all methods and other static class attributes of the buttons.
-STATIC const mp_rom_map_elem_t buttons_locals_dict[] = {
+static const mp_rom_map_elem_t buttons_locals_dict[] = {
     { MP_ROM_QSTR(MP_QSTR_pressed), MP_ROM_PTR(&buttons_pressed_obj) },
     { MP_ROM_QSTR(MP_QSTR_pressed_since), MP_ROM_PTR(&buttons_pressed_since_obj) },
     { MP_ROM_QSTR(MP_QSTR_read_value), MP_ROM_PTR(&buttons_read_value_obj) },
     { MP_ROM_QSTR(MP_QSTR_set_pin), MP_ROM_PTR(&buttons_set_pin_obj) },
     { MP_ROM_QSTR(MP_QSTR_turn_off_cube), MP_ROM_PTR(&buttons_turn_off_cube_obj) },
 };
-STATIC MP_DEFINE_CONST_DICT(buttons_locals_dict_obj, buttons_locals_dict);
+static MP_DEFINE_CONST_DICT(buttons_locals_dict_obj, buttons_locals_dict);
 
 // This defines the type(buttons) object.
 MP_DEFINE_CONST_OBJ_TYPE(

micropython/modules/opencube_brick/led.c

@@ -17,7 +17,7 @@ typedef struct _led_obj_t {
 //static void pcf_irq_handler(void);
 
 // Called on led init
-STATIC mp_obj_t led_make_new(const mp_obj_type_t* type, size_t n_args, size_t n_kw, const mp_obj_t* args) {
+static mp_obj_t led_make_new(const mp_obj_type_t* type, size_t n_args, size_t n_kw, const mp_obj_t* args) {
     led_obj_t *self = m_new_obj(led_obj_t);
     self->base.type = type;
     opencube_lock_i2c_or_raise();
@@ -26,44 +26,44 @@ STATIC mp_obj_t led_make_new(const mp_obj_type_t* type, size_t n_args, size_t n_
     return MP_OBJ_FROM_PTR(self);
 }
 
-STATIC void led_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+static void led_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
   mp_printf(print, "Led");
 }
 
-STATIC mp_obj_t led_on(mp_obj_t self_in) {
+static mp_obj_t led_on(mp_obj_t self_in) {
     opencube_lock_i2c_or_raise();
     PCF8575_write_pin(USER_LED_RPIN, false);
     opencube_unlock_i2c();
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_on_obj, led_on);
+static MP_DEFINE_CONST_FUN_OBJ_1(led_on_obj, led_on);
 
-STATIC mp_obj_t led_off(mp_obj_t self_in) {
+static mp_obj_t led_off(mp_obj_t self_in) {
     opencube_lock_i2c_or_raise();
     PCF8575_write_pin(USER_LED_RPIN, true);
     opencube_unlock_i2c();
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_off_obj, led_off);
+static MP_DEFINE_CONST_FUN_OBJ_1(led_off_obj, led_off);
 
-STATIC mp_obj_t led_toggle(mp_obj_t self_in) {
+static mp_obj_t led_toggle(mp_obj_t self_in) {
     opencube_lock_i2c_or_raise();
     PCF8575_toggle_pin(USER_LED_RPIN);
     opencube_unlock_i2c();
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_toggle_obj, led_toggle);
+static MP_DEFINE_CONST_FUN_OBJ_1(led_toggle_obj, led_toggle);
 
 
 // This collects all methods and other static class attributes of the led.
-STATIC const mp_rom_map_elem_t led_locals_dict[] = {
+static const mp_rom_map_elem_t led_locals_dict[] = {
     { MP_ROM_QSTR(MP_QSTR_on), MP_ROM_PTR(&led_on_obj) },
     { MP_ROM_QSTR(MP_QSTR_off), MP_ROM_PTR(&led_off_obj) },
     { MP_ROM_QSTR(MP_QSTR_toggle), MP_ROM_PTR(&led_toggle_obj) },
     { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&led_off_obj) },
     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&led_off_obj) },
 };
-STATIC MP_DEFINE_CONST_DICT(led_locals_dict_obj, led_locals_dict);
+static MP_DEFINE_CONST_DICT(led_locals_dict_obj, led_locals_dict);
 
 // This defines the type(led) object.
 MP_DEFINE_CONST_OBJ_TYPE(

micropython/modules/opencube_motors/encoder_api.c

@@ -9,6 +9,8 @@ typedef struct {
   bool reverse;
 } encoder_obj_t;
 
+const mp_obj_type_t opencube_encoder_type;
+
 static mp_obj_t encoder_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
   mp_arg_check_num(n_args, n_kw, 1, 2, false);
 
@@ -18,7 +20,7 @@ static mp_obj_t encoder_make_new(const mp_obj_type_t *type, size_t n_args, size_
   }
 
   opencube_encoders_init(port);
-  encoder_obj_t *self = m_new_obj_with_finaliser(encoder_obj_t);
+  encoder_obj_t *self = mp_obj_malloc_with_finaliser(encoder_obj_t, &opencube_encoder_type);
   self->base.type = type;
   self->port = port;
   self->ref_position = opencube_encoders_get_position(self->port);

micropython/modules/opencube_motors/motor_api.c

@@ -169,7 +169,7 @@ static mp_obj_t motor_finalizer(mp_obj_t self_in) {
     opencube_motor_deinit(self->port);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(motor_finalizer_obj, motor_finalizer);
+static MP_DEFINE_CONST_FUN_OBJ_1(motor_finalizer_obj, motor_finalizer);
 
 // This collects all methods and other static class attributes of the Motor.
 static const mp_rom_map_elem_t motor_locals_dict[] = {

micropython/modules/opencube_pindefs/opencube_hw.h

@@ -19,8 +19,8 @@
 #define ADS1119_I2C_ADDR     0x40 // 1000000 (A0+A1=GND)
 
 // ==== I2C bus for external sensors ====
-#define UTZ_I2C_SDA_PIN = 16
-#define UTZ_I2C_SCK_PIN = 17
+#define UTZ_I2C_SDA_PIN 16
+#define UTZ_I2C_SCK_PIN 17
 #define UTZ_I2C_BUS i2c0
 #define UTZ_I2C_BAUD_RATE 30000
 #define MULTICUBE_I2C_BAUD_RATE 100000 

mpy @ 3823aeb0

-Subproject commit 41ed01f1394ea608bf9d055120d671e2765cd9b7
+Subproject commit 3823aeb0f14c04084eba6566164d9b7dbd9e7ced