메모리 대신 인터럽트 방식으로 통신

Author: EcmaXp

src/Makefile

@@ -74,7 +74,6 @@ SRC_LIB = $(addprefix lib/,\
 
 SRC_MP_LIB = $(addprefix lib/,\
 	utils/sys_stdio_mphal.c \
-	utils/stdout_helpers.c \
 	utils/interrupt_char.c \
 	utils/pyexec.c \
 	libc/string0.c \

src/machine.c

@@ -3,7 +3,6 @@
 #include "py/objexcept.h"
 #include "lib/utils/interrupt_char.h"
 #include "gccollect.h"
-#include "openpie_mcu.h"
 #include "machine.h"
 #include "syscall.h"
 
@@ -38,9 +37,9 @@ void Reset_Handler(void) {
         *dest++ = 0;
     }
 
-    OPENPIE_CONTROLLER->PENDING = (uint32_t) &MP_STATE_VM(mp_pending_exception);
-    OPENPIE_CONTROLLER->EXCEPTION = (uint32_t) &MP_STATE_VM(mp_kbd_exception);
-    OPENPIE_CONTROLLER->INTR_CHAR = (uint32_t) &mp_interrupt_char;
+    // OPENPIE_CONTROLLER->PENDING = (uint32_t) &MP_STATE_VM(mp_pending_exception);
+    // OPENPIE_CONTROLLER->EXCEPTION = (uint32_t) &MP_STATE_VM(mp_kbd_exception);
+    // OPENPIE_CONTROLLER->INTR_CHAR = (uint32_t) &mp_interrupt_char;
 
     // jump to board initialisation
     _start();

src/main.c

@@ -12,7 +12,6 @@
 #include "gccollect.h"
 #include "machine.h"
 #include "syscall.h"
-#include "openpie_mcu.h"
 #include <stdarg.h>
 
 #define _debug(s) __syscall2(SYS_DEBUG, (int)s, (int)strlen(s));
@@ -50,11 +49,8 @@ int main(int argc, char **argv) {
         mp_pystack_init(&pystack, &pystack[MP_ARRAY_SIZE(pystack)]);
 #endif
 
-        size_t ram_size = (size_t)OPENPIE_CONTROLLER->RAM_SIZE;
-        if (!ram_size)
-            gc_init(&_ram_start, &_ram_end);
-        else
-            gc_init(&_ram_start, (&_ram_start) + ram_size);
+        size_t ram_size = (size_t) __syscall1(SYS_INFO, SYS_INFO_RAM_SIZE);
+        gc_init(&_ram_start, (&_ram_start) + ram_size);
 
         mp_init();
         mp_obj_list_init(mp_sys_path, 0);
@@ -88,13 +84,8 @@ int main(int argc, char **argv) {
 
         nlr_pop();
     } else {
-        if (nlr_push(&nlr) == 0) {
-            mp_obj_print_exception(&debug_print, (mp_obj_t) nlr.ret_val);
-            mp_deinit();
-            nlr_pop();
-        } else {
-            __fatal_error("unexpected error");
-        }
+        mp_obj_print_exception(&debug_print, (mp_obj_t) nlr.ret_val);
+        mp_deinit();
     }
 
     return 0;

src/modmachine.c

@@ -11,7 +11,6 @@
 #include "py/objstr.h"
 #include "py/runtime.h"
 #include "openpie_vfs.h"
-#include "openpie_mcu.h"
 #include "syscall.h"
 #include "msgpack.h"
 #include "py/mphal.h"
@@ -129,15 +128,36 @@ STATIC mp_obj_t usystem_repl_call(mp_obj_t func, mp_obj_t locals_obj) {
 MP_DEFINE_CONST_FUN_OBJ_2(usystem_repl_call_obj, usystem_repl_call);
 
 
-mp_obj_t print_hook = NULL;
+mp_obj_t interrupt_hook_obj = mp_const_none;
+
+STATIC mp_obj_t usystem_interrupt_hook(mp_obj_t hook) {
+    interrupt_hook_obj = hook;
+    return mp_const_none;
+}
+
+MP_DEFINE_CONST_FUN_OBJ_1(usystem_interrupt_hook_obj, usystem_interrupt_hook);
+
+
+mp_obj_t print_hook_obj = mp_const_none;
 
 STATIC mp_obj_t usystem_print_hook(mp_obj_t hook) {
-    print_hook = hook;
+    print_hook_obj = hook;
     return mp_const_none;
 }
 
 MP_DEFINE_CONST_FUN_OBJ_1(usystem_print_hook_obj, usystem_print_hook);
 
+
+mp_obj_t input_hook_obj = mp_const_none;
+
+STATIC mp_obj_t usystem_input_hook(mp_obj_t hook) {
+    input_hook_obj = hook;
+    return mp_const_none;
+}
+
+MP_DEFINE_CONST_FUN_OBJ_1(usystem_input_hook_obj, usystem_input_hook);
+
+
 STATIC mp_obj_t usystem_invoke(size_t n_args, const mp_obj_t *args) {
     byte *data = NULL;
     size_t size = 0;
@@ -186,12 +206,13 @@ STATIC mp_obj_t usystem_invoke(size_t n_args, const mp_obj_t *args) {
 MP_DEFINE_CONST_FUN_OBJ_VAR(usystem_invoke_obj, 2, usystem_invoke);
 
 
-STATIC mp_obj_t usystem_signal() {
-    void *result = (void *) __syscall1(SYS_REQUEST, 0); // 0 = signal
+STATIC mp_obj_t usystem_signal(mp_obj_t ticks_obj) {
+    mp_int_t ticks = mp_obj_get_int(ticks_obj);
+    void *result = (void *) __syscall2(SYS_SIGNAL, SYS_SIGNAL_REQUEST, (int) ticks); // sleep with ticks
     return parse_2(result);
 }
 
-MP_DEFINE_CONST_FUN_OBJ_0(usystem_signal_obj, usystem_signal);
+MP_DEFINE_CONST_FUN_OBJ_1(usystem_signal_obj, usystem_signal);
 
 
 STATIC mp_obj_t usystem_components() {
@@ -237,28 +258,6 @@ STATIC mp_obj_t usystem_annotations(mp_obj_t address_obj, mp_obj_t method_obj) {
 MP_DEFINE_CONST_FUN_OBJ_2(usystem_annotations_obj, usystem_annotations);
 
 
-mp_obj_t usystem_set_stdin_char(mp_obj_t obj) {
-    if (MP_OBJ_IS_INT(obj)) {
-        mp_int_t value = mp_obj_get_int(obj);
-        OPENPIE_IO->RXR = value;
-        return mp_const_true;
-    }
-
-    return mp_const_false;
-}
-
-MP_DEFINE_CONST_FUN_OBJ_1(usystem_set_stdin_char_obj, usystem_set_stdin_char);
-
-
-mp_obj_t usystem_get_stdout_str() {
-    void *result = (void *) __syscall1(SYS_LEGACY, SYS_LEGACY_usystem_get_stdout_str);
-    return parse_2(result);
-}
-
-MP_DEFINE_CONST_FUN_OBJ_0(usystem_get_stdout_str_obj, usystem_get_stdout_str);
-
-
-
 mp_obj_t usystem_shutdown() {
     __syscall1(SYS_CONTROL, SYS_CONTROL_SHUTDOWN);
     __fatal_error("shutdown failure");
@@ -293,23 +292,21 @@ STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
         {MP_ROM_QSTR(MP_QSTR_repl_compile),   MP_ROM_PTR(&usystem_repl_compile_obj)},
         {MP_ROM_QSTR(MP_QSTR_repl_call),      MP_ROM_PTR(&usystem_repl_call_obj)},
 
+        {MP_ROM_QSTR(MP_QSTR_interrupt_hook), MP_ROM_PTR(&usystem_interrupt_hook_obj)},
+        {MP_ROM_QSTR(MP_QSTR_input_hook),     MP_ROM_PTR(&usystem_input_hook_obj)},
         {MP_ROM_QSTR(MP_QSTR_print_hook),     MP_ROM_PTR(&usystem_print_hook_obj)},
         {MP_ROM_QSTR(MP_QSTR_invoke),         MP_ROM_PTR(&usystem_invoke_obj)},
         {MP_ROM_QSTR(MP_QSTR_signal),         MP_ROM_PTR(&usystem_signal_obj)},
         {MP_ROM_QSTR(MP_QSTR_components),     MP_ROM_PTR(&usystem_components_obj)},
         {MP_ROM_QSTR(MP_QSTR_methods),        MP_ROM_PTR(&usystem_methods_obj)},
         {MP_ROM_QSTR(MP_QSTR_annotations),    MP_ROM_PTR(&usystem_annotations_obj)},
-        {MP_ROM_QSTR(MP_QSTR_set_stdin_char), MP_ROM_PTR(&usystem_set_stdin_char_obj)},
-        {MP_ROM_QSTR(MP_QSTR_get_stdout_str), MP_ROM_PTR(&usystem_get_stdout_str_obj)},
         {MP_ROM_QSTR(MP_QSTR_shutdown),       MP_ROM_PTR(&usystem_shutdown_obj)},
         {MP_ROM_QSTR(MP_QSTR_reboot),         MP_ROM_PTR(&usystem_reboot_obj)},
         {MP_ROM_QSTR(MP_QSTR_debug),          MP_ROM_PTR(&usystem_debug_obj)},
 
-        /*
         {MP_ROM_QSTR(MP_QSTR_mem8),     MP_ROM_PTR(&machine_mem8_obj)},
         {MP_ROM_QSTR(MP_QSTR_mem16),    MP_ROM_PTR(&machine_mem16_obj)},
         {MP_ROM_QSTR(MP_QSTR_mem32),    MP_ROM_PTR(&machine_mem32_obj)},
-        */
 };
 STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table);
 

src/modmachine.h

@@ -1,7 +1,4 @@
 #ifndef MICROPY_INCLUDED_MODMACHINE_H
 #define MICROPY_INCLUDED_MODMACHINE_H
 
-#include "openpie_mcu.h"
-
-
 #endif

src/modutime.c

@@ -6,14 +6,15 @@
 #include "py/obj.h"
 #include "lib/timeutils/timeutils.h"
 #include "extmod/utime_mphal.h"
-#include "openpie_mcu.h"
 
 STATIC const mp_rom_map_elem_t time_module_globals_table[] = {
         {MP_ROM_QSTR(MP_QSTR___name__),   MP_ROM_QSTR(MP_QSTR_utime)},
 
         {MP_ROM_QSTR(MP_QSTR_sleep),      MP_ROM_PTR(&mp_utime_sleep_obj)},
         {MP_ROM_QSTR(MP_QSTR_sleep_ms),   MP_ROM_PTR(&mp_utime_sleep_ms_obj)},
+        {MP_ROM_QSTR(MP_QSTR_sleep_us),   MP_ROM_PTR(&mp_utime_sleep_us_obj)},
         {MP_ROM_QSTR(MP_QSTR_ticks_ms),   MP_ROM_PTR(&mp_utime_ticks_ms_obj)},
+        {MP_ROM_QSTR(MP_QSTR_ticks_us),   MP_ROM_PTR(&mp_utime_ticks_us_obj)},
         {MP_ROM_QSTR(MP_QSTR_ticks_cpu),  MP_ROM_PTR(&mp_utime_ticks_cpu_obj)},
         {MP_ROM_QSTR(MP_QSTR_ticks_add),  MP_ROM_PTR(&mp_utime_ticks_add_obj)},
         {MP_ROM_QSTR(MP_QSTR_ticks_diff), MP_ROM_PTR(&mp_utime_ticks_diff_obj)},

src/mphalport.c

@@ -1,47 +1,48 @@
 #include <stdint.h>
 #include <stdio.h>
+#include <string.h>
 
 #include "py/runtime.h"
 #include "py/objstr.h"
-#include "openpie_mcu.h"
 #include "mphalport.h"
 #include "syscall.h"
 
-extern mp_obj_t print_hook;
+extern mp_obj_t interrupt_hook_obj;
+extern mp_obj_t input_hook_obj;
+extern mp_obj_t print_hook_obj;
 
 int mp_hal_stdin_rx_chr(void) {
-    unsigned char c = 0;
-    while (c == 0) {
-        mp_handle_pending();
-        c = OPENPIE_IO->RXR;
+    if (input_hook_obj == mp_const_none) {
+        return 0;
+    } else {
+        mp_obj_t obj = mp_call_function_0(input_hook_obj);
+        return (int) mp_obj_get_int(obj);
     }
+}
 
-    return c;
+void mp_hal_stdout_tx_str(const char *str) {
+    mp_hal_stdout_tx_strn(str, strlen(str));
 }
 
 void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
-    mp_obj_t signal_buf = mp_obj_new_str(str, len);
-    nlr_buf_t nlr;
-
-    if (nlr_push(&nlr) == 0) {
-        mp_obj_t handler = mp_obj_dict_get(
-                MP_OBJ_FROM_PTR(&MP_STATE_VM(dict_main)),
-                MP_OBJ_NEW_QSTR(MP_QSTR_print_handler)
-        );
-
-        mp_call_function_1_protected(handler, signal_buf);
-        nlr_pop();
-    } else {
+    if (print_hook_obj == mp_const_none) {
         __syscall2(SYS_DEBUG, (int)str, (int)len);
+    } else {
+        mp_obj_t str_obj = mp_obj_new_str(str, len);
+        mp_call_function_1(print_hook_obj, str_obj);
     }
 }
 
+void mp_hal_stdout_tx_strn_cooked(const char *str, size_t len) {
+    mp_hal_stdout_tx_strn(str, len);
+}
+
 void mp_hal_delay_ms(mp_uint_t ms) {
     uint32_t start = mp_hal_ticks_ms();
     extern void mp_handle_pending(void);
     while (mp_hal_ticks_ms() - start < ms) {
         mp_handle_pending();
-        OPENPIE_CONTROLLER->IDLE = 1;
+        // OPENPIE_CONTROLLER->IDLE = 1;
     }
 }
 
@@ -52,14 +53,15 @@ void mp_hal_delay_us(mp_uint_t us) {
     }
 }
 
-mp_uint_t mp_hal_ticks_us(void) {
-    return mp_hal_ticks_ms() * 1000;
+mp_uint_t mp_hal_ticks_ms(void) {
+    return (mp_uint_t) __syscall1(SYS_TIMER, SYS_TIMER_TICKS_MS);
 }
 
-mp_uint_t mp_hal_ticks_ms(void) {
-    return RTC->TICKS_MS;
+mp_uint_t mp_hal_ticks_us(void) {
+    return (mp_uint_t) __syscall1(SYS_TIMER, SYS_TIMER_TICKS_US);
 }
 
 mp_uint_t mp_hal_ticks_cpu(void) {
-    return OPENPIE_CONTROLLER->INSNS;
+    // return OPENPIE_CONTROLLER->INSNS;
+    return 0; // return (mp_uint_t) __syscall1(SYS_TIMER, SYS_TIMER_TICKS_CPU);
 }

src/mphalport.h

@@ -1,6 +1,14 @@
 #include "py/obj.h"
 #include "modmachine.h"
 
+int mp_hal_stdin_rx_chr(void);
+
+void mp_hal_stdout_tx_str(const char *str);
+
+void mp_hal_stdout_tx_strn(const char *str, size_t len);
+
+void mp_hal_stdout_tx_strn_cooked(const char *str, size_t len);
+
 void mp_hal_delay_ms(mp_uint_t ms);
 
 void mp_hal_delay_us(mp_uint_t us);
@@ -12,5 +20,3 @@ mp_uint_t mp_hal_ticks_us(void);
 mp_uint_t mp_hal_ticks_cpu(void);
 
 void mp_hal_set_interrupt_char(int c);
-
-static inline void mp_hal_delay_us_fast(uint32_t us) { return; }