Fixes some of the compile errors.

Still needs more work...

Author: kdschlosser

ext_mod/threading/common/inc/thread_event.h

@@ -6,7 +6,7 @@
 #ifndef __THREAD_EVENT_H__
     #define __THREAD_EVENT_H__
 
-    typedef struct _thread_event_t thread_event_t; // needs to be defined in port
+    #include "thread_port.h"
 
     typedef struct _mp_obj_thread_event_t {
         mp_obj_base_t base;

ext_mod/threading/common/inc/thread_lock.h

@@ -6,7 +6,7 @@
 #ifndef __THREAD_LOCK_H__
     #define __THREAD_LOCK_H__
 
-    typedef struct _thread_lock_t thread_lock_t; // needs to be defined in port
+    #include "thread_port.h"
 
     typedef struct _mp_obj_lock_t {
         mp_obj_base_t base;

ext_mod/threading/common/inc/thread_rlock.h

@@ -5,12 +5,12 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
 
-#include "thread_common.h"
+#include "threading.h"
 
 #ifndef __THREAD_RLOCK_H__
     #define __THREAD_RLOCK_H__
 
-    typedef struct _thread_rlock_t thread_rlock_t; // needs to be defined in port
+    #include "thread_port.h"
 
     typedef struct _mp_obj_rlock_t {
         mp_obj_base_t base;

ext_mod/threading/common/inc/thread_semaphore.h

@@ -6,7 +6,7 @@
 #ifndef __THREAD_SEMAPHORE_H__
     #define __THREAD_SEMAPHORE_H__
 
-    typedef struct _thread_semaphore_t thread_semaphore_t; // needs to be defined in port
+    #include "thread_port.h"
 
     typedef struct _mp_obj_thread_semaphore_t {
         mp_obj_base_t base;
@@ -17,7 +17,7 @@
     uint16_t threading_semaphore_get_count(thread_semaphore_t *sem); // needs to be defined in port
     bool threading_semaphore_acquire(thread_semaphore_t *sem, int32_t wait_ms); // needs to be defined in port
     void threading_semaphore_release(thread_semaphore_t *sem); // needs to be defined in port
-    void threading_semaphore_init(thread_semaphore_t *sem); // needs to be defined in port
+    void threading_semaphore_init(thread_semaphore_t *sem, uint16_t start_value); // needs to be defined in port
     void threading_semaphore_delete(thread_semaphore_t *sem); // needs to be defined in port
 
     extern const mp_obj_type_t mp_type_threading_semaphore_t;

ext_mod/threading/common/inc/thread_thread.h

@@ -6,7 +6,7 @@
 #ifndef __THREAD_THREAD_H__
     #define __THREAD_THREAD_H__
 
-    typedef struct _thread_t thread_t; // needs to be defined in port
+    #include "thread_port.h"
 
     typedef struct _thread_entry_args_t {
         mp_obj_dict_t *dict_locals;

ext_mod/threading/common/src/multiprocessing.c

@@ -11,7 +11,7 @@ void multiprocessing_init(void)
 {
     processes = (mp_obj_t *)malloc(sizeof(mp_obj_t) * mp_get_cpu_count());
 
-    mp_obj_thread_t * main_thread = (mp_obj_thread_t *)MP_OBJ_TO_PTR(threading_main_thread());
+    mp_obj_thread_t * main_thread = (mp_obj_thread_t *)MP_OBJ_TO_PTR(mp_get_main_thread());
     uint8_t curr_core_id = mp_get_process_core(&main_thread->thread);
     processes[curr_core_id] = MP_OBJ_FROM_PTR(main_thread);
 }
@@ -46,7 +46,7 @@ static MP_DEFINE_CONST_FUN_OBJ_0(multiprocessing_active_children_obj, multiproce
 
 static mp_obj_t multiprocessing_cpu_count(void)
 {
-    return mp_obj_new_int_truncated(mp_get_cpu_count());
+    return mp_obj_new_int_from_uint(mp_get_cpu_count());
 }
 
 static MP_DEFINE_CONST_FUN_OBJ_0(multiprocessing_cpu_count_obj, multiprocessing_cpu_count);
@@ -63,7 +63,7 @@ static MP_DEFINE_CONST_FUN_OBJ_0(multiprocessing_current_process_obj, multiproce
 
 static mp_obj_t multiprocessing_parent_process(void)
 {
-    mp_obj_t main_thread = threading_main_thread();
+    // mp_obj_t main_thread = mp_get_main_thread();
     uint8_t core_id = mp_get_current_process_core();
 
     return processes[core_id];

ext_mod/threading/common/src/thread_event.c

@@ -6,14 +6,15 @@
 #include "freertos/semphr.h"
 #include "freertos/event_groups.h"
 
+#include "threading.h"
 #include "thread_event.h"
 
 
+
 static mp_obj_t event_is_set(mp_obj_t self_in)
 {
     mp_obj_thread_event_t *self = MP_OBJ_TO_PTR(self_in);
-    bool res = threading_event_isset(&self->event);
-    return mp_obj_new_bool(res);
+    return mp_obj_new_bool(self->event.is_set);
 }
 
 static MP_DEFINE_CONST_FUN_OBJ_1(event_is_set_obj, event_is_set);
@@ -23,6 +24,7 @@ static MP_DEFINE_CONST_FUN_OBJ_1(event_is_set_obj, event_is_set);
 static mp_obj_t event_set(mp_obj_t self_in)
 {
     mp_obj_thread_event_t *self = MP_OBJ_TO_PTR(self_in);
+    self->event.is_set = true;
     threading_event_set(&self->event);
     return mp_const_none;
 }
@@ -34,6 +36,7 @@ static MP_DEFINE_CONST_FUN_OBJ_1(event_set_obj, event_set);
 static mp_obj_t event_clear(mp_obj_t self_in)
 {
     mp_obj_thread_event_t *self = MP_OBJ_TO_PTR(self_in);
+    self->event.is_set = false;
     threading_event_clear(&self->event);
     return mp_const_none;
 }
@@ -64,7 +67,7 @@ static mp_obj_t event_wait(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw
     }
 
     int32_t timeout = (int32_t)(timeout_f * 1000);
-    threading_event_wait(&(self->event, timeout);
+    threading_event_wait(&self->event, timeout);
     return mp_const_none;
 }
 
@@ -82,7 +85,7 @@ static mp_obj_t event__del__(mp_obj_t self_in)
 static MP_DEFINE_CONST_FUN_OBJ_1(event__del__obj, event__del__);
 
 
-static mp_obj_t threading_event_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
+static mp_obj_t thread_event_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
 {
     THREAD_UNUSED(type);
     THREAD_UNUSED(n_args);
@@ -92,7 +95,7 @@ static mp_obj_t threading_event_make_new(const mp_obj_type_t *type, size_t n_arg
     // create new object
     mp_obj_thread_event_t *self = m_new_obj(mp_obj_thread_event_t);
     self->base.type = &mp_type_threading_event_t;
-
+    self->event.is_set = false;
     threading_event_init(&self->event);
     return MP_OBJ_FROM_PTR(self);
 }
@@ -113,17 +116,17 @@ MP_DEFINE_CONST_OBJ_TYPE(
     MP_QSTR_Event,
     MP_TYPE_FLAG_NONE,
     // print, mp_lv_grad_t_print,
-    make_new, threading_event_make_new,
+    make_new, thread_event_make_new,
     // binary_op, lv_struct_binary_op,
     // subscr, lv_struct_subscr,
     // attr, mp_threading_semaphore_attr,
-    locals_dict, &threading_event_locals_dict
+    locals_dict, &event_locals_dict
     // buffer, mp_blob_get_buffer,
     // parent, &mp_lv_base_struct_type
 );
 
 
-static mp_obj_t multiprocessing_event_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
+static mp_obj_t multiprocess_event_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
 {
     THREAD_UNUSED(type);
     THREAD_UNUSED(n_args);
@@ -133,7 +136,7 @@ static mp_obj_t multiprocessing_event_make_new(const mp_obj_type_t *type, size_t
     // create new object
     mp_obj_thread_event_t *self = m_new_obj(mp_obj_thread_event_t);
     self->base.type = &mp_type_multiprocessing_event_t;
-
+    self->event.is_set = false;
     threading_event_init(&self->event);
     return MP_OBJ_FROM_PTR(self);
 }
@@ -143,7 +146,7 @@ MP_DEFINE_CONST_OBJ_TYPE(
     MP_QSTR_Event,
     MP_TYPE_FLAG_NONE,
     // print, mp_lv_grad_t_print,
-    make_new, multiprocessing_event_make_new,
+    make_new, multiprocess_event_make_new,
     // binary_op, lv_struct_binary_op,
     // subscr, lv_struct_subscr,
     // attr, mp_threading_semaphore_attr,

ext_mod/threading/common/src/thread_lock.c

@@ -3,10 +3,10 @@
 #include "py/runtime.h"
 
 #include "thread_lock.h"
-#include "thread_common.h"
+#include "threading.h"
 
 
-static mp_obj_t thread_lock_acquire(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args)
+static mp_obj_t lock_acquire(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args)
 {
     enum { ARG_self, ARG_blocking, ARG_timeout };
 
@@ -36,76 +36,77 @@ static mp_obj_t thread_lock_acquire(size_t n_args, const mp_obj_t *pos_args, mp_
         timeout = 0;
     }
 
-    self->ref_count += 1;
-    int ret = threading_lock_acquire(&self->mutex, timeout);
+    self->lock.ref_count += 1;
+    int ret = threading_lock_acquire(&self->lock, timeout);
 
     if (ret == 0) {
-        self->ref_count -= 1;
+        self->lock.ref_count -= 1;
         return mp_const_false;
     } else if (ret == 1) {
         return mp_const_true;
     } else {
-        self->ref_count -= 1;
+        self->lock.ref_count -= 1;
         mp_raise_OSError(-ret);
         return mp_const_none;
     }
 }
 
-static MP_DEFINE_CONST_FUN_OBJ_KW(thread_lock_acquire_obj, 3, thread_lock_acquire);
+static MP_DEFINE_CONST_FUN_OBJ_KW(lock_acquire_obj, 3, lock_acquire);
 
 
-static mp_obj_t thread_lock__enter__(size_t n_args, const mp_obj_t *args)
+static mp_obj_t lock__enter__(size_t n_args, const mp_obj_t *args)
 {
     (void)n_args; // unused
     mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(args[0]);
 
-    self->ref_count += 1;
-    threading_lock_acquire(&self->mutex, -1);
+    self->lock.ref_count += 1;
+    threading_lock_acquire(&self->lock, -1);
     return mp_const_none
 }
 
 
-static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(thread_lock__enter__obj, 1, 1, thread_lock__enter__);
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(lock__enter__obj, 1, 1, lock__enter__);
 
 
-static mp_obj_t thread_lock_release(mp_obj_t self_in)
+static mp_obj_t lock_release(mp_obj_t self_in)
 {
     mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(self_in);
-    if (self->ref_count == 0) {
+    if (self->lock.ref_count == 0) {
         mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("Lock is already released");
     } else {
         threading_lock_release(&self->mutex);
     }
 
-    self->ref_count -= 1;
+    self->lock.ref_count -= 1;
 
     return mp_const_none;
 }
 
-static MP_DEFINE_CONST_FUN_OBJ_1(thread_lock_release_obj, thread_lock_release);
+static MP_DEFINE_CONST_FUN_OBJ_1(lock_release_obj, lock_release);
 
 
-static mp_obj_t thread_lock__exit__(size_t n_args, const mp_obj_t *args)
+static mp_obj_t lock__exit__(size_t n_args, const mp_obj_t *args)
 {
     (void)n_args; // unused
-    return thread_lock_release(args[0]);
+    lock_release(args[0]);
+    return mp_const_none;
 }
 
-static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(thread_lock__exit__obj, 4, 4, thread_lock__exit__);
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(lock__exit__obj, 4, 4, lock__exit__);
 
 
-static mp_obj_t thread_lock_locked(mp_obj_t self_in)
+static mp_obj_t lock_locked(mp_obj_t self_in)
 {
     mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(self_in);
 
-    return mp_obj_new_bool(self->ref_count != 0);
+    return mp_obj_new_bool(self->lock.ref_count != 0);
 }
 
-static MP_DEFINE_CONST_FUN_OBJ_1(thread_lock_locked_obj, thread_lock_locked);
+static MP_DEFINE_CONST_FUN_OBJ_1(lock_locked_obj, lock_locked);
 
 
 
-static mp_obj_t threading_lock_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
+static mp_obj_t thread_lock_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
 {
     THREAD_UNUSED(type);
     THREAD_UNUSED(n_args);
@@ -115,39 +116,39 @@ static mp_obj_t threading_lock_make_new(const mp_obj_type_t *type, size_t n_args
     mp_obj_thread_lock_t *self = m_new_obj(mp_obj_thread_lock_t);
     self->base.type = &mp_type_threading_lock_t;
 
-    lock_init(&self->mutex);
+    threading_lock_init(&self->lock;
     self->locked = false;
     return MP_OBJ_FROM_PTR(self);
 }
 
 
-static const mp_rom_map_elem_t threading_lock_locals_dict_table[] = {
+static const mp_rom_map_elem_t lock_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_acquire), MP_ROM_PTR(&thread_lock_acquire_obj) },
     { MP_ROM_QSTR(MP_QSTR_release), MP_ROM_PTR(&thread_lock_release_obj) },
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&thread_lock__enter__obj) },
     { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&thread_lock__exit__obj) },
     { MP_ROM_QSTR(MP_QSTR_locked), MP_ROM_PTR(&thread_lock_locked_obj) },
 };
 
-static MP_DEFINE_CONST_DICT(threading_lock_locals_dict, threading_lock_locals_dict_table);
+static MP_DEFINE_CONST_DICT(lock_locals_dict, lock_locals_dict_table);
 
 
 MP_DEFINE_CONST_OBJ_TYPE(
     mp_type_threading_lock_t,
     MP_QSTR_Lock,
     MP_TYPE_FLAG_NONE,
     // print, mp_lv_grad_t_print,
-    make_new, threading_lock_make_new,
+    make_new, thread_lock_make_new,
     // binary_op, lv_struct_binary_op,
     // subscr, lv_struct_subscr,
     // attr, mp_threading_semaphore_attr,
-    locals_dict, &threading_lock_locals_dict
+    locals_dict, &lock_locals_dict
     // buffer, mp_blob_get_buffer,
     // parent, &mp_lv_base_struct_type
 );
 
 
-static mp_obj_t multiprocessing_lock_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
+static mp_obj_t multiprocess_lock_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
 {
     THREAD_UNUSED(type);
     THREAD_UNUSED(n_args);
@@ -157,33 +158,22 @@ static mp_obj_t multiprocessing_lock_make_new(const mp_obj_type_t *type, size_t
     mp_obj_thread_lock_t *self = m_new_obj(mp_obj_thread_lock_t);
     self->base.type = &mp_type_multiprocessing_lock_t;
 
-    lock_init(&self->mutex);
-    self->ref_count = 0;
+    threading_lock_init(&self->lock);
+    self->lock.ref_count = 0;
     return MP_OBJ_FROM_PTR(self);
 }
 
 
-static const mp_rom_map_elem_t multiprocessing_lock_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR_acquire), MP_ROM_PTR(&thread_lock_acquire_obj) },
-    { MP_ROM_QSTR(MP_QSTR_release), MP_ROM_PTR(&thread_lock_release_obj) },
-    { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&thread_lock__enter__obj) },
-    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&thread_lock__exit__obj) },
-    { MP_ROM_QSTR(MP_QSTR_locked), MP_ROM_PTR(&thread_lock_locked_obj) },
-};
-
-static MP_DEFINE_CONST_DICT(multiprocessing_lock_locals_dict, multiprocessing_lock_locals_dict_table);
-
-
 MP_DEFINE_CONST_OBJ_TYPE(
     mp_type_multiprocessing_lock_t,
     MP_QSTR_Lock,
     MP_TYPE_FLAG_NONE,
     // print, mp_lv_grad_t_print,
-    make_new, multiprocessing_lock_make_new,
+    make_new, multiprocess_lock_make_new,
     // binary_op, lv_struct_binary_op,
     // subscr, lv_struct_subscr,
     // attr, mp_threading_semaphore_attr,
-    locals_dict, &multiprocessing_lock_locals_dict
+    locals_dict, &lock_locals_dict
     // buffer, mp_blob_get_buffer,
     // parent, &mp_lv_base_struct_type
 );