MicroPython
[UNIX] Simple timer implementation got error in mp_stack_usage function
#12151
-
|
Hello everyone, I want to implement a simple timer object in the C layer for the UNIX port. I have tried to create the same application in the top layer (MPY layer) but I got a 1-second delay for a 60 seconds timeout so I want to check whether implementing it in the lower layer will reduce the delay. What I want to achieve is a simple timer that receives a timeout in a second and a callback function without args from timer import Timer
import time
def callback():
print("Hello from callback")
def main():
tm = Timer(1, callback) # timeout in second
tm.start()
time.sleep(2)
tm.stop()
if __name__ == "__main__":
main()This is what I have implemented so far #include "py/runtime.h"
#include "py/obj.h"
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
typedef struct _mp_timer_t {
mp_obj_base_t base;
mp_int_t period;
mp_obj_t callback;
pthread_t thread;
} mp_timer_t;
void *timer_thread(void *arg) {
mp_timer_t *timer = (mp_timer_t *)arg;
// wait for timer->period seconds
while (timer->period > 0)
{
usleep(1000);
timer->period--;
}
// call callback
mp_call_function_0(timer->callback);
return NULL;
}
STATIC mp_obj_t timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
mp_timer_t *timer = m_new_obj(mp_timer_t);
timer->base.type = type;
timer->period = mp_obj_get_int(args[0]);
if (timer->period < 0)
{
timer->period = 0;
}
if (!mp_obj_is_callable(args[1]))
{
m_del_obj(mp_timer_t, timer);
mp_raise_ValueError(MP_ERROR_TEXT("callback must be callable"));
}
timer->callback = args[1];
timer->thread = NULL;
return MP_OBJ_FROM_PTR(timer);
}
STATIC mp_obj_t timer_start(mp_obj_t self_in) {
mp_timer_t *timer = MP_OBJ_TO_PTR(self_in);
if (timer->thread == NULL)
{
if (pthread_create(&timer->thread, NULL, timer_thread, timer) != 0)
{
m_del_obj(mp_timer_t, timer);
mp_raise_ValueError(MP_ERROR_TEXT("cannot create thread"));
}
}
return mp_const_none;
}
STATIC mp_obj_t timer_stop(mp_obj_t self_in) {
mp_timer_t *timer = MP_OBJ_TO_PTR(self_in);
if (timer->thread != NULL) {
pthread_cancel(timer->thread);
timer->thread = NULL;
}
m_del_obj(mp_timer_t, timer);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(timer_start_obj, timer_start);
STATIC MP_DEFINE_CONST_FUN_OBJ_1(timer_stop_obj, timer_stop);
STATIC const mp_rom_map_elem_t timer_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_start), MP_ROM_PTR(&timer_start_obj) },
{ MP_ROM_QSTR(MP_QSTR_stop), MP_ROM_PTR(&timer_stop_obj) },
{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&timer_stop_obj) },
};
STATIC MP_DEFINE_CONST_DICT(timer_locals_dict, timer_locals_dict_table);
MP_DEFINE_CONST_OBJ_TYPE(
timer_type,
MP_QSTR_Serial,
MP_TYPE_FLAG_NONE,
make_new, timer_make_new,
locals_dict, &timer_locals_dict
);
STATIC const mp_rom_map_elem_t mp_module_timer_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_timer) },
{ MP_ROM_QSTR(MP_QSTR_Timer), MP_ROM_PTR(&timer_type) },
};
STATIC MP_DEFINE_CONST_DICT(mp_module_timer_globals, mp_module_timer_globals_table);
const mp_obj_module_t mp_module_timer = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t*)&mp_module_timer_globals,
};
MP_REGISTER_MODULE(MP_QSTR_timer, mp_module_timer);The problem arises when the This is the debug output This is the screenshot of the call stack My question is, what prevents this code from running properly? why does the I appreciate your help |
Beta Was this translation helpful? Give feedback.
Replies: 3 comments 3 replies
-
|
It seems like this could be implemented in just a few lines of Python instead of a C module. If you are really interested in sticking with C, I would suggest looking at https://github.com/micropython/micropython/blob/master/ports/unix/modtime.c#L88 for how to get more accurate timing (still not super accurate for < 100ms). In your implementation, I think the problem is because the thread is not a MicroPython thread but a regular C thread and you are trying to call MicroPython code there without doing the required thread initialization needed by MicroPython. |
Beta Was this translation helpful? Give feedback.
-
|
I understand your suggestion about considering a Python implementation, and I appreciate your input. However, I have a particular reason for wanting to stick with the C implementation in this case. The MicroPython version of this implementation hasn't demonstrated satisfactory accuracy in my scenario. Your observation about the thread type is on point. The thread I used was a standard C thread, and I suspect that the problem is related to not initializing MicroPython properly within this thread. By the way, thanks for sharing that link. I'll definitely look into it to see if the techniques mentioned will help me implement this simple timer. |
Beta Was this translation helpful? Give feedback.
-
|
We've used unix micropython threads to simulate a Timer in the past, in case it helps: import time
import _thread
class Timer:
def __init__(self, timer_id):
self.id = timer_id
self._callback = None
self._period_ms = None
self._stop = False
_thread.start_new_thread(self._timer, ())
def init(self, freq, callback):
self._callback = callback
self._period_ms = 1000 // freq
def deinit(self):
self._stop = True
def _timer(self):
while True:
if self._stop:
break
if self._freq is None:
time.sleep_ms(100)
start = time.ticks_ms()
if self._callback:
try:
self._callback(self)
except Exception as ex:
import sys
sys.print_exception(ex)
taken = time.ticks_diff(time.ticks_ms(), start)
time.sleep_ms(min(0, self._period_ms-taken)) |
Beta Was this translation helpful? Give feedback.
-
|
Thank you for your reply. |
Beta Was this translation helpful? Give feedback.
-
|
Sure, good luck with the C impl, it's good practice on how to expose C functions to micropython code! One note; I see in your code above you're not taking acount for any time taken in the callback before restarting the timeout, so time between calls will be (period + callback time). FWIW I found the python _thread based timer above to be accurate to within a couple of ms at worst, but it depends on the system load of the PC and what's being run in the main thread etc. I expect the exact same issues can occur with the C implementation as there's really not much difference between them at this point! |
Beta Was this translation helpful? Give feedback.
-
|
It turns out the UNIX port already has a timer implementation in the micropython-lib |
Beta Was this translation helpful? Give feedback.
It turns out the UNIX port already has a timer implementation in the micropython-lib