micropython: add micropython component

components/language/micropython/port/Makefile

@@ -0,0 +1,68 @@
+BUILD = build
+ifneq ($(PORT_BOARD_DIR), )
+BOARD_DIR := $(subst \,/,$(PORT_BOARD_DIR))
+else
+$(warning "PORT_BOARD_DIR should be specified")
+endif
+BOARD_DIR ?= board
+
+include ../py/mkenv.mk
+-include $(BOARD_DIR)/mpconfigboard.mk
+
+MICROPY_ROM_TEXT_COMPRESSION ?= 1
+
+include $(TOP)/py/py.mk
+
+# Select the cross compile prefix
+# CROSS_COMPILE ?= arm-none-eabi-
+
+# Set CFLAGS and libraries.	
+INC = $(addprefix -I,\
+	. \
+	modules \
+	$(TOP) \
+	$(BUILD) \
+	$(BOARD_DIR) \
+	)
+
+DEF_C = -DMP_GEN_HDR=1 \
+		$(PORT_DEF_C)
+
+CFLAGS = $(INC) $(DEF_C)
+
+# Set SRC_QSTR
+SHARED_SRC_C = $(addprefix $(TOP)/shared/,\
+	readline/readline.c \
+	runtime/sys_stdio_mphal.c \
+	runtime/pyexec.c \
+	runtime/stdout_helpers.c \
+	)
+
+EXTMOD_SRC_C += $(addprefix $(TOP)/extmod/,\
+	modnetwork.c \
+	modusocket.c \
+	)
+
+PORT_MODULE_SRC_C = \
+	$(wildcard ./modules/*.c) \
+
+PORT_BOARD_SRC_C = \
+	$(filter-out $(BOARD_DIR)/hal/*.c,$(wildcard $(BOARD_DIR)/*.c)) \
+
+SRC_QSTR += $(SHARED_SRC_C) $(EXTMOD_SRC_C) $(PORT_MODULE_SRC_C) $(PORT_BOARD_SRC_C)
+
+# Target genhdr directory
+TARGET_GENHDR_DIR ?= ./genhdr/
+
+# Generate header
+genhdr: $(HEADER_BUILD)/mpversion.h $(HEADER_BUILD)/qstrdefs.generated.h $(HEADER_BUILD)/moduledefs.h | $(TARGET_GENHDR_DIR)
+	$(CP) $^ $(TARGET_GENHDR_DIR)
+
+clean-build:
+	$(ECHO) "REMOVE $(BUILD)"
+	$(Q)$(RM) -rf $(BUILD)
+
+$(TARGET_GENHDR_DIR): 
+	$(MKDIR) -p $@
+
+include $(TOP)/py/mkrules.mk

components/language/micropython/port/help.c

@@ -0,0 +1,46 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/builtin.h"
+
+#if MICROPY_PY_BUILTINS_HELP
+
+const char tencentos_tiny_help_text[] = 
+    "Welcome to MicroPython on TencentOS tiny!\n"
+    "\n"
+    "For online docs please visit http://docs.micropython.org/\n"
+    "\n"
+    "Control commands:\n"
+    "  CTRL-A        -- on a blank line, enter raw REPL mode\n"
+    "  CTRL-B        -- on a blank line, enter normal REPL mode\n"
+    "  CTRL-C        -- interrupt a running program\n"
+    "  CTRL-D        -- on a blank line, exit or do a soft reset\n"
+    "  CTRL-E        -- on a blank line, enter paste mode\n"
+    "\n"
+    "For further help on a specific object, type help(obj)\n"
+;
+
+#endif

components/language/micropython/port/modules/machine_hw_spi.c

@@ -0,0 +1,153 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+#if MICROPY_PY_MACHINE_SPI
+
+#include "py/mphal.h"
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "extmod/machine_spi.h"
+#include "modmachine.h"
+
+#if !(MP_GEN_HDR)
+#include "tos_k.h"
+#include "mp_tos_hal_spi.h"
+#endif
+
+typedef struct _machine_hard_spi_obj_t {
+    mp_obj_base_t base;
+    hal_spi_port_t port;
+    hal_spi_t spi;
+    uint16_t timeout;
+    uint16_t timeout_char;
+    uint8_t init;
+} machine_hard_spi_obj_t;
+
+STATIC machine_hard_spi_obj_t machine_hard_spi_obj_all[MICROPY_HW_SPI_NUM];
+
+STATIC machine_hard_spi_obj_t *machine_hard_spi_find(mp_obj_t user_obj) {
+    machine_hard_spi_obj_t *spi = NULL;
+    if (mp_obj_is_int(user_obj)) {
+        mp_uint_t spi_id = mp_obj_get_int(user_obj);
+        if (spi_id < MICROPY_HW_SPI_NUM)
+            spi = &machine_hard_spi_obj_all[spi_id];
+            if (spi->base.type == NULL) {
+                spi->base.type = &machine_hard_spi_type;
+                spi->port = (hal_spi_port_t)spi_id;
+								spi->init = 0;
+            }
+    }
+    return spi;
+}
+
+STATIC void machine_hard_spi_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    machine_hard_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_printf(print, "SPI(%u)", self->port);
+}
+
+STATIC mp_obj_t machine_hard_spi_init_helper(machine_hard_spi_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+
+mp_obj_t machine_hard_spi_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    // check arguments
+    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+
+    machine_hard_spi_obj_t *spi = machine_hard_spi_find(args[0]);
+    if (spi == NULL) {
+        mp_raise_msg(&mp_type_ValueError, MP_ERROR_TEXT("invalid spi"));
+    }
+
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+    machine_hard_spi_init_helper(spi, n_args - 1, args + 1, &kw_args);
+
+    return MP_OBJ_FROM_PTR(spi);
+}
+
+STATIC mp_obj_t machine_hard_spi_init_helper(machine_hard_spi_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    /*
+    enum { ARG_baudrate, ARG_polarity, ARG_phase, ARG_bits, ARG_firstbit };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_baudrate, MP_ARG_INT, {.u_int = 500000} },
+        { MP_QSTR_polarity, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_phase,    MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_bits,     MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 8} },
+        { MP_QSTR_firstbit, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = SPI_FIRSTBIT_MSB} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    */
+
+    if (self->init) {
+        mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("SPI(%u) has been initialized"), self->port);
+    }
+
+    if (0 != tos_hal_spi_init(&self->spi, self->port)) {
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("SPI(%u) doesn't exist"), self->port);
+    }
+
+    // FIXME: should not be fixed
+    self->timeout = 100;
+    self->timeout_char = 1;
+
+    self->init = 1;
+    
+    return mp_const_none;
+}
+
+STATIC void machine_hard_spi_init(mp_obj_base_t *self_in, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    machine_hard_spi_obj_t *self = (machine_hard_spi_obj_t *)self_in;
+    machine_hard_spi_init_helper(self, n_args, pos_args, kw_args);
+}
+
+STATIC void machine_hard_spi_deinit(mp_obj_base_t *self_in) {
+    machine_hard_spi_obj_t *self = (machine_hard_spi_obj_t *)self_in;
+    if (self->init) {
+        tos_hal_spi_deinit(&self->spi);
+        self->init = 0;
+    }
+}
+
+STATIC void machine_hard_spi_transfer(mp_obj_base_t *self_in, size_t len, const uint8_t *src, uint8_t *dest) {
+    machine_hard_spi_obj_t *self = (machine_hard_spi_obj_t *)self_in;
+    tos_hal_spi_transfer(&self->spi, src, dest, len, self->timeout + len * self->timeout_char);
+}
+
+STATIC const mp_machine_spi_p_t machine_hard_spi_p = {
+    .init = machine_hard_spi_init,
+    .deinit = machine_hard_spi_deinit,
+    .transfer = machine_hard_spi_transfer,
+};
+
+const mp_obj_type_t machine_hard_spi_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_SPI,
+    .print = machine_hard_spi_print,
+    .make_new = machine_hard_spi_make_new,
+    .protocol = &machine_hard_spi_p,
+    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
+};
+#endif /* MICROPY_PY_MACHINE_SPI */

components/language/micropython/port/modules/machine_hw_spi.h

@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_MACHINE_HW_SPI_H
+#define MICROPY_INCLUDED_MACHINE_HW_SPI_H
+
+#include "py/obj.h"
+
+extern const mp_obj_type_t machine_hard_spi_type;
+
+#endif /* MICROPY_INCLUDED_MACHINE_HW_SPI_H */

components/language/micropython/port/modules/machine_pin.c

@@ -0,0 +1,281 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+
+#if MICROPY_PY_MACHINE
+
+#include "py/mphal.h"
+#include "py/runtime.h"
+#include "extmod/virtpin.h"
+#include "modmachine.h"
+#if !(MP_GEN_HDR)
+#include "mp_tos_hal_pin.h"
+#endif
+
+typedef struct  _machine_pin_obj_t {
+    mp_obj_base_t base;
+    hal_pin_port_t port;
+    hal_pin_t pin;
+    qstr name;
+    mp_obj_t handler;
+} machine_pin_obj_t;
+
+void mp_hal_pin_write(machine_pin_obj_t *pin, int v) {
+    if (tos_hal_pin_write(&pin->pin, v) != 0) {
+        mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("Pin(%q) failed to be written"), pin->name);
+    }
+}
+
+int mp_hal_pin_read(machine_pin_obj_t * pin) {
+    int v = tos_hal_pin_read(&pin->pin);
+    if (v < 0) {
+        mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("Pin(%q) failed to be read"), pin->name);
+    }
+    return v;
+}
+
+void mp_hal_pin_config(machine_pin_obj_t * pin, uint32_t mode) {
+    if (tos_hal_pin_init(&pin->pin, pin->port, (hal_pin_mode_t)mode) != 0) {
+        mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("Pin(%q) failed to be configured"), pin->name);
+    }
+}
+
+qstr mp_hal_pin_name(machine_pin_obj_t *pin) {
+    return pin->name;
+}
+
+extern const mp_obj_dict_t machine_pins_locals_dict;
+
+machine_pin_obj_t *mp_hal_get_pin_obj(mp_obj_t name) {
+    const mp_map_t *named_map = &machine_pins_locals_dict.map;
+    mp_map_elem_t *named_elem = mp_map_lookup((mp_map_t *)named_map, name, MP_MAP_LOOKUP);
+    machine_pin_obj_t *pin;
+    if (named_elem != NULL && named_elem->value != MP_OBJ_NULL) {
+        pin = m_new_obj(machine_pin_obj_t);
+        pin->port = mp_obj_get_int(named_elem->value);
+        pin->name = mp_obj_str_get_qstr(name);
+        pin->base.type = &machine_pin_type;
+        pin->handler = mp_const_none;
+        return pin;
+    }
+    return NULL;
+}
+
+
+void machine_pins_init(void) {
+    
+}
+
+STATIC machine_pin_obj_t *machine_pin_find(mp_obj_t user_obj) {
+    machine_pin_obj_t *pin_obj = mp_hal_get_pin_obj(user_obj);
+    if (pin_obj) {
+        return pin_obj;
+    }
+    mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Pin(%s) doesn't exist"), mp_obj_str_get_str(user_obj));
+}
+
+STATIC void machine_pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    machine_pin_obj_t *self = self_in;
+    mp_printf(print, "Pin(%q)", self->name);
+}
+
+STATIC mp_obj_t machine_pin_obj_init_helper(machine_pin_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+
+mp_obj_t mp_pin_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, MP_OBJ_FUN_ARGS_MAX, true);
+
+    // Run an argument through the mapper and return the result.
+    machine_pin_obj_t *pin = machine_pin_find(args[0]);
+    if (pin == NULL) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
+    }
+
+    if (n_args > 1 || n_kw > 0) {
+        // pin mode given, so configure this GPIO
+        mp_map_t kw_args;
+        mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+        machine_pin_obj_init_helper(pin, n_args - 1, args + 1, &kw_args);
+    }
+
+    return MP_OBJ_FROM_PTR(pin);
+}
+
+STATIC mp_obj_t machine_pin_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, 1, false);
+    machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (n_args == 0) {
+        // get pin
+        return MP_OBJ_NEW_SMALL_INT(mp_hal_pin_read(self));
+    } else {
+        // set pin
+        mp_hal_pin_write(self, mp_obj_is_true(args[0]));
+        return mp_const_none;
+    }
+}
+
+// pin.init(mode=None, pull=-1, *, value, drive, hold)
+STATIC mp_obj_t machine_pin_obj_init_helper(machine_pin_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_mode, ARG_value };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_mode, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_value, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL}},
+    };
+    
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // get mode
+    uint mode = args[ARG_mode].u_int;
+    if (!MP_HAL_IS_PIN_MODE(mode)) {
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid pin mode: %d"), mode);
+    }
+
+    // if given, set the pin value before initialising to prevent glitches
+    if (args[ARG_value].u_obj != MP_OBJ_NULL) {
+        mp_hal_pin_write(self, mp_obj_is_true(args[ARG_value].u_obj));
+    }
+
+    // configure the GPIO as requested
+    mp_hal_pin_config(self, mode);
+
+    return mp_const_none;
+}
+
+// pin.init(mode, pull)
+STATIC mp_obj_t machine_pin_obj_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    return machine_pin_obj_init_helper(MP_OBJ_TO_PTR(args[0]), n_args - 1, args + 1, kw_args);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_pin_init_obj, 1, machine_pin_obj_init);
+
+// pin.value([value])
+STATIC mp_obj_t machine_pin_value(size_t n_args, const mp_obj_t *args) {
+    return machine_pin_call(args[0], n_args - 1, 0, args + 1);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_pin_value_obj, 1, 2, machine_pin_value);
+
+// pin.off()
+STATIC mp_obj_t machine_pin_off(mp_obj_t self_in) {
+    machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_hal_pin_low(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_off_obj, machine_pin_off);
+
+// pin.on()
+STATIC mp_obj_t machine_pin_on(mp_obj_t self_in) {
+    machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_hal_pin_high(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_on_obj, machine_pin_on);
+
+void machine_pin_isr_handler(void *arg) {
+    machine_pin_obj_t *self = (machine_pin_obj_t *)arg;
+    mp_sched_schedule(self->handler, MP_OBJ_FROM_PTR(self));
+}
+
+// pin.irq(handler=None,  trigger=IRQ_FALLING|IRQ_RISING)
+STATIC mp_obj_t machine_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_handler, ARG_trigger };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_handler, MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_trigger, MP_ARG_INT, {.u_int = HAL_PIN_IRQ_RISING|HAL_PIN_IRQ_FALLING } },
+    };
+    machine_pin_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    if (n_args > 1 || kw_args->used != 0) {
+        // set handler
+        mp_obj_t handler = args[ARG_handler].u_obj;
+        if (handler == mp_const_none || !mp_obj_is_callable(handler)) {
+            mp_raise_msg(&mp_type_ValueError, MP_ERROR_TEXT("invalid irq handler"));
+        }
+        self->handler = handler;
+
+        // configure irq
+        if ((tos_hal_pin_irq_callback(&self->pin, machine_pin_isr_handler, self) != 0)
+        ||  (tos_hal_pin_irq(&self->pin, (hal_pin_irq_t)args[ARG_trigger].u_int) != 0)) {
+            mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("Pin(%q) failed to configure irq"), self->name);
+        }
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_pin_irq_obj, 1, machine_pin_irq);
+
+STATIC const mp_rom_map_elem_t machine_pin_locals_dict_table[] = {
+    // instance methods
+    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_pin_init_obj) },
+    { MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&machine_pin_value_obj) },
+    { MP_ROM_QSTR(MP_QSTR_off), MP_ROM_PTR(&machine_pin_off_obj) },
+    { MP_ROM_QSTR(MP_QSTR_on), MP_ROM_PTR(&machine_pin_on_obj) },
+    { MP_ROM_QSTR(MP_QSTR_irq), MP_ROM_PTR(&machine_pin_irq_obj) },
+
+    // class constants
+    { MP_ROM_QSTR(MP_QSTR_IN),        MP_ROM_INT(HAL_PIN_MODE_INPUT) },
+    { MP_ROM_QSTR(MP_QSTR_OUT),       MP_ROM_INT(HAL_PIN_MODE_OUTPUT) },
+    { MP_ROM_QSTR(MP_QSTR_OPEN_DRAIN), MP_ROM_INT(HAL_PIN_MODE_OUTPUT_OD) },
+    { MP_ROM_QSTR(MP_QSTR_IN_PULLUP),   MP_ROM_INT(HAL_PIN_MODE_INPUT_PULLUP) },
+    { MP_ROM_QSTR(MP_QSTR_IN_PULLDOWN), MP_ROM_INT(HAL_PIN_MODE_INPUT_PULLDOWN) },
+    { MP_ROM_QSTR(MP_QSTR_IRQ_RISING), MP_ROM_INT(HAL_PIN_IRQ_RISING) },
+    { MP_ROM_QSTR(MP_QSTR_IRQ_FALLING), MP_ROM_INT(HAL_PIN_IRQ_FALLING) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(machine_pin_locals_dict, machine_pin_locals_dict_table);
+
+STATIC mp_uint_t pin_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    (void)errcode;
+    machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+    switch (request) {
+        case MP_PIN_READ: {
+            return mp_hal_pin_read(self);
+        }
+        case MP_PIN_WRITE: {
+            mp_hal_pin_write(self, arg);
+            return 0;
+        }
+    }
+    return (mp_uint_t)-1;
+}
+
+STATIC const mp_pin_p_t pin_pin_p = {
+    .ioctl = pin_ioctl,
+};
+
+const mp_obj_type_t machine_pin_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Pin,
+    .print = machine_pin_print,
+    .make_new = mp_pin_make_new,
+    .call = machine_pin_call,
+    .protocol = &pin_pin_p,
+    .locals_dict = (mp_obj_t)&machine_pin_locals_dict,
+};
+
+#endif /* MICROPY_PY_MACHINE */

components/language/micropython/port/modules/machine_pin.h

@@ -0,0 +1,36 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_MACHINE_PIN_H
+#define MICROPY_INCLUDED_MACHINE_PIN_H
+
+#include "py/obj.h"
+
+extern const mp_obj_type_t machine_pin_type;
+
+void machine_pins_init(void);
+
+#endif /* MICROPY_INCLUDED_MACHINE_PIN_H */

components/language/micropython/port/modules/machine_timer.c

@@ -0,0 +1,232 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+
+#if MICROPY_PY_MACHINE
+
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "modmachine.h"
+#if !(MP_GEN_HDR)
+#include "tos_k.h"
+#endif
+
+typedef struct _machine_timer_obj_t {
+    mp_obj_base_t base;
+    k_timer_t timer;
+    mp_obj_t callback;
+    mp_int_t period;
+    uint8_t mode;
+    uint8_t init : 1;
+    uint8_t running : 1;
+    struct _machine_timer_obj_t *next;
+} machine_timer_obj_t;
+
+STATIC void machine_timer_disable(machine_timer_obj_t *self);
+
+void machine_timer_deinit_all(void) {
+    machine_timer_obj_t *t = MP_STATE_PORT(machine_timer_obj_head);
+    for (; t != NULL; t = t->next) {
+        machine_timer_disable(t);
+    }
+}
+
+STATIC void machine_timer_handler(void *arg) {
+    machine_timer_obj_t *self = (machine_timer_obj_t *)arg;
+    mp_sched_schedule(self->callback, MP_OBJ_FROM_PTR(self));
+    if (self->mode == TOS_OPT_TIMER_ONESHOT) 
+        self->running = 0;
+}
+
+STATIC void machine_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    machine_timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->init) {
+        qstr mode = self->mode == TOS_OPT_TIMER_ONESHOT ? MP_QSTR_ONE_SHOT : MP_QSTR_PERIODIC;
+        mp_printf(print, "Timer(%p, mode=%q, period=%u, running=%u)", self, mode, self->period, self->running);
+    } else {
+        mp_printf(print, "Timer(%p)", self);
+    }
+}
+
+STATIC mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+
+mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    // check arguments
+    // mp_arg_check_num(n_args, n_kw, 0, MP_OBJ_FUN_ARGS_MAX, true);
+    machine_timer_obj_t *self = mp_obj_malloc(machine_timer_obj_t, &machine_timer_type);
+    self->init = 0;
+    self->mode = TOS_OPT_TIMER_ONESHOT;
+    self->running = 0;
+    self->period = 1000;
+    self->callback = mp_const_none;
+    memset(&self->timer, 0x00, sizeof(k_timer_t));
+    self->next = MP_STATE_PORT(machine_timer_obj_head);
+    MP_STATE_PORT(machine_timer_obj_head) = self;
+
+    if (n_args > 0 || n_kw > 0) {
+        // start the timer
+        mp_map_t kw_args;
+        mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+        machine_timer_init_helper(self, n_args, args, &kw_args);
+    }
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC void machine_timer_enable(machine_timer_obj_t *self) {
+    k_tick_t period_ticks = tos_millisec2tick(self->period);
+    k_err_t err = tos_timer_create(&self->timer, period_ticks, period_ticks, 
+                                    machine_timer_handler, self, self->mode);
+    if (err != K_ERR_NONE) {
+        mp_raise_msg(&mp_type_OSError, "can't create timer");
+    }
+}
+
+STATIC void machine_timer_disable(machine_timer_obj_t *self) {
+    if (self->init) {
+        tos_timer_destroy(&self->timer);
+        self->callback = mp_const_none;
+        self->init = 0;
+    }
+}
+
+STATIC mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_mode, ARG_callback, ARG_tick_hz, ARG_period, ARG_freq };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = TOS_OPT_TIMER_PERIODIC} },
+        { MP_QSTR_callback, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_tick_hz, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1000} },
+        { MP_QSTR_period, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
+        #if MICROPY_PY_BUILTINS_FLOAT
+        { MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        #else
+        { MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
+        #endif
+    };
+
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    uint64_t period = self->period;
+    #if MICROPY_PY_BUILTINS_FLOAT
+    if (args[ARG_freq].u_obj != mp_const_none) {
+        // frequency specified in Hz
+        period = (uint64_t)(MICROPY_FLOAT_CONST(1000.0) / mp_obj_get_float(args[ARG_freq].u_obj));
+    }
+    #else
+    if (args[ARG_freq].u_int != 0xffffffff) {
+        // frequency specified in Hz
+        period = 1000 / (args[ARG_freq].u_int);
+    }
+    #endif
+    else {
+        // period specified
+        period = ((uint64_t)args[ARG_period].u_int * 1000 / args[ARG_tick_hz].u_int);
+    }
+
+    if (period < 1) {
+        period = 1;
+    } else if (period >= 0x40000000) {
+        mp_raise_msg(&mp_type_ValueError, MP_ERROR_TEXT("period too large"));
+    }
+    self->period = period;
+
+    if (args[ARG_mode].u_int != TOS_OPT_TIMER_ONESHOT && args[ARG_mode].u_int != TOS_OPT_TIMER_PERIODIC) {
+        mp_raise_msg(&mp_type_ValueError, MP_ERROR_TEXT("invalid timer mode"));
+    }
+    self->mode = args[ARG_mode].u_int;
+    self->callback = args[ARG_callback].u_obj;
+
+    // create timer
+    machine_timer_enable(self);
+
+    self->init = 1;
+
+    if (self->callback == mp_const_none) {
+        // do nothing
+    } else if (mp_obj_is_callable(self->callback)) {
+        // start timer
+        self->running = 1;
+        tos_timer_start(&self->timer);
+    }
+    
+    return mp_const_none;
+}
+
+// timer.init()
+STATIC mp_obj_t machine_timer_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    machine_timer_disable(args[0]);
+    return machine_timer_init_helper(args[0], n_args - 1, args + 1, kw_args);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_timer_init_obj, 1, machine_timer_init);
+
+// timer.deinit()
+STATIC mp_obj_t machine_timer_deinit(mp_obj_t self_in) {
+    machine_timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    machine_timer_disable(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_deinit_obj, machine_timer_deinit);
+
+STATIC mp_obj_t machine_timer_callback(mp_obj_t self_in, mp_obj_t callback) {
+    machine_timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (callback == mp_const_none) {
+        tos_timer_stop(&self->timer);
+        self->running = 0;
+        self->callback = mp_const_none;
+    } else if (mp_obj_is_callable(callback)) {
+        self->callback = callback;
+        if (!self->running) {
+            // restart timer
+            tos_timer_start(&self->timer);
+            self->running = 1;
+        }
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(machine_timer_callback_obj, machine_timer_callback);
+
+STATIC const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_timer_init_obj) },
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_timer_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_callback), MP_ROM_PTR(&machine_timer_callback_obj) },
+    
+    { MP_ROM_QSTR(MP_QSTR_ONE_SHOT), MP_ROM_INT(TOS_OPT_TIMER_ONESHOT) },
+    { MP_ROM_QSTR(MP_QSTR_PERIODIC), MP_ROM_INT(TOS_OPT_TIMER_PERIODIC) },
+};
+STATIC MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
+
+const mp_obj_type_t machine_timer_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Timer,
+    .print = machine_timer_print,
+    .make_new = machine_timer_make_new,
+    .locals_dict = (mp_obj_dict_t *)&machine_timer_locals_dict,
+};
+
+#endif /* MICROPY_PY_MACHINE */

components/language/micropython/port/modules/machine_timer.h

@@ -0,0 +1,36 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_MACHINE_TIMER_H
+#define MICROPY_INCLUDED_MACHINE_TIMER_H
+
+#include "py/obj.h"
+
+extern const mp_obj_type_t machine_timer_type;
+
+void machine_timer_deinit_all(void);
+
+#endif /* MICROPY_INCLUDED_MACHINE_TIMER_H */

components/language/micropython/port/modules/machine_uart.c

@@ -0,0 +1,404 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+#include "py/mphal.h"
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "py/stream.h"
+#include "shared/runtime/interrupt_char.h"
+#include "modmachine.h"
+#if !(MP_GEN_HDR)
+#include "tos_k.h"
+#include "tos_at.h"
+#include "tos_hal_uart.h"
+#include "mp_tos_hal_uart.h"
+#endif
+
+typedef struct _machine_uart_obj_t {
+    mp_obj_base_t base;
+    hal_uart_port_t port;
+    hal_uart_t uart;
+    // k_mutex_t tx_lock;
+    uint8_t rx_char_buf;
+    k_sem_t rx_sem;
+    k_chr_fifo_t rx_fifo;
+    uint8_t *rx_fifo_buf;
+    uint16_t rx_fifo_buf_len;
+    uint16_t timeout;           // timeout waiting for first char
+    uint16_t timeout_char;      // timeout waiting between chars
+    at_agent_t *at_agent;
+    uint8_t init;
+    uint8_t attached_to_repl;
+} machine_uart_obj_t;
+
+STATIC machine_uart_obj_t machine_uart_obj_all[MICROPY_HW_UART_NUM];
+
+void machine_uart_rx_start(machine_uart_obj_t *self) {
+    if (self->rx_fifo_buf || self->at_agent) {
+        tos_hal_uart_recv_start(&self->uart, &self->rx_char_buf, 1);
+    }
+}
+
+void mp_hal_uart_rx_start(uint32_t uart_id) {
+    machine_uart_obj_t *self = &machine_uart_obj_all[uart_id];
+    if (self == NULL || !self->init) {
+        return;
+    }
+    machine_uart_rx_start(self);
+}
+
+int machine_uart_rx_chr(machine_uart_obj_t *self) {
+
+    k_err_t err;
+    uint8_t chr;
+
+    if (!self->init)
+        return -1;
+    
+    machine_uart_rx_start(self);
+
+    if (tos_chr_fifo_is_empty(&self->rx_fifo)) {
+        if (tos_sem_pend(&self->rx_sem, self->timeout) != K_ERR_NONE) {
+            return -1;
+        }
+    }
+    err = tos_chr_fifo_pop(&self->rx_fifo, &chr);
+
+    return err == K_ERR_NONE ? chr : -1;
+}
+
+int machine_uart_tx_strn(machine_uart_obj_t *self, const char *str, mp_uint_t len) {
+    int ret = 0;
+    
+    // tos_mutex_pend(&self->tx_lock);
+    ret = tos_hal_uart_write(&self->uart, (const uint8_t *)str, len, 0xFFFF);
+    // tos_mutex_post(&self->tx_lock);
+
+    return ret;
+}
+
+void machine_uart_attach_to_repl(machine_uart_obj_t *self, uint8_t attached) {
+    self->attached_to_repl = attached;
+}
+
+void mp_hal_uart_irq_handler(uint32_t uart_id) {
+
+    machine_uart_obj_t *self;
+    if (uart_id >= MICROPY_HW_UART_NUM) {
+        return;
+    }
+
+    self = &machine_uart_obj_all[uart_id];
+    if (self == NULL || !self->init) {
+        return;
+    }
+    
+    machine_uart_rx_start(self);
+
+    #if MICROPY_PY_NETWORK
+    // if UART is used as AT agent
+    if (self->at_agent) {
+        tos_at_uart_input_byte(self->at_agent, self->rx_char_buf);
+        return;
+    }
+    #endif
+
+    if (self->attached_to_repl) {
+        if (mp_interrupt_char == self->rx_char_buf) {
+            mp_sched_keyboard_interrupt();
+            return;
+        }
+    }
+
+    if (self->rx_fifo_buf) {
+        tos_chr_fifo_push(&self->rx_fifo, self->rx_char_buf);
+        tos_sem_post(&self->rx_sem);
+    }
+}
+
+void machine_uart_set_at_agent(machine_uart_obj_t *self, at_agent_t *at_agent) {
+    self->at_agent = at_agent;
+}
+
+hal_uart_port_t machine_uart_get_port(machine_uart_obj_t *self) {
+    return self->port;
+}
+
+
+
+STATIC machine_uart_obj_t *machine_uart_find(mp_obj_t user_obj) {
+    machine_uart_obj_t *uart = NULL;
+    if (mp_obj_is_int(user_obj)) {
+        mp_uint_t uart_id = mp_obj_get_int(user_obj);
+        if (uart_id < MICROPY_HW_UART_NUM)
+            uart = &machine_uart_obj_all[uart_id];
+            if (uart->base.type == NULL) {
+                uart->base.type = &machine_uart_type;
+                uart->port = (hal_uart_port_t)uart_id;
+                uart->rx_fifo_buf = NULL;
+                uart->at_agent = NULL;
+								uart->init = 0;
+            }
+    }
+    return uart;
+}
+
+STATIC void machine_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->init) {
+        mp_printf(print, "UART(%u, rxbuf=%u, timeout=%u, timeout_char=%u)", self->port, self->rx_fifo_buf_len, self->timeout, self->timeout_char);
+    } else {
+        mp_printf(print, "UART(%u)", self->port);
+    }
+}
+
+STATIC mp_obj_t machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+
+mp_obj_t machine_uart_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    // check arguments
+    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+
+    machine_uart_obj_t *uart = machine_uart_find(args[0]);
+    if (uart == NULL) {
+        mp_raise_msg(&mp_type_ValueError, MP_ERROR_TEXT("invalid uart"));
+    }
+
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+    if (!uart->init) {
+        machine_uart_init_helper(uart, n_args - 1, args + 1, &kw_args);
+    }
+
+    return MP_OBJ_FROM_PTR(uart);
+}
+
+STATIC mp_obj_t machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { /*ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_flow, ARG_txbuf, */ARG_rxbuf, ARG_timeout, ARG_timeout_char };
+    static const mp_arg_t allowed_args[] = {
+        // { MP_QSTR_baudrate, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 9600} },
+        // { MP_QSTR_bits, MP_ARG_INT, {.u_int = 8} },
+        // { MP_QSTR_parity, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        // { MP_QSTR_stop, MP_ARG_INT, {.u_int = 1} },
+        // { MP_QSTR_flow, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int}}
+        // { MP_QSTR_txbuf, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_rxbuf, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 64} },
+        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    if (self->init) {
+        mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("UART(%u) has been initialized"), self->port);
+    }
+
+    if (0 != tos_hal_uart_init(&self->uart, self->port)) {
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%u) doesn't exist"), self->port);
+    }
+
+    if (args[ARG_rxbuf].u_int >= 0) {
+        self->rx_fifo_buf_len = args[ARG_rxbuf].u_int;
+    }
+    self->timeout = args[ARG_timeout].u_int;
+    self->timeout_char = args[ARG_timeout_char].u_int;
+    // minimal char timeout is 2ms
+    if (self->timeout_char < 2) {
+        self->timeout_char = 2;
+    }
+    self->attached_to_repl = 0;
+
+    // reset rx fifo buffer before reallocation
+    if (self->rx_fifo_buf) {
+        tos_mmheap_free(self->rx_fifo_buf);
+        self->rx_fifo_buf = NULL;
+    }
+    // TODO: reset rx fifo and rx sem?
+    // tos_chr_fifo_destroy(&self->rx_fifo);
+    // tos_sem_destroy(&self->rx_sem);
+    // setup rx fifo
+    if (self->rx_fifo_buf_len > 0) {
+        self->rx_fifo_buf = tos_mmheap_alloc(self->rx_fifo_buf_len);
+        if (!self->rx_fifo_buf) {
+            goto err0;
+        }
+        tos_chr_fifo_create(&self->rx_fifo, self->rx_fifo_buf, self->rx_fifo_buf_len);
+        if (K_ERR_NONE != tos_sem_create(&self->rx_sem, 0)) {
+            goto err1;
+        }
+        machine_uart_rx_start(self);
+    }
+
+    self->init = 1;
+
+    return mp_const_none;
+		
+err1:
+    tos_mmheap_free(self->rx_fifo_buf);
+    self->rx_fifo_buf = NULL;
+    tos_chr_fifo_destroy(&self->rx_fifo);
+err0:
+    tos_hal_uart_deinit(&self->uart);
+    mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't create rxbuf"));
+
+    return mp_const_none;
+}
+
+// uart.init()
+STATIC mp_obj_t machine_uart_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    return machine_uart_init_helper(MP_OBJ_TO_PTR(args[0]), n_args - 1, args + 1, kw_args);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_uart_init_obj, 1, machine_uart_init);
+
+// uart.deinit()
+STATIC mp_obj_t machine_uart_deinit(mp_obj_t self_in) {
+    machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->init) {
+        if (self->rx_fifo_buf) {
+            tos_mmheap_free(self->rx_fifo_buf);
+            self->rx_fifo_buf = NULL;
+        }
+        tos_chr_fifo_destroy(&self->rx_fifo);
+        tos_sem_destroy(&self->rx_sem);
+        tos_hal_uart_deinit(&self->uart);
+        self->init = 0;
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_deinit_obj, machine_uart_deinit);
+
+// uart.any()
+// Return `True` if any characters waiting, else `False`.
+STATIC mp_obj_t machine_uart_any(mp_obj_t self_in) {
+    machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->rx_fifo_buf) {
+        return MP_OBJ_NEW_SMALL_INT(!tos_chr_fifo_is_empty(&self->rx_fifo));
+    } else {
+        return MP_OBJ_NEW_SMALL_INT(0);
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_any_obj, machine_uart_any);
+
+STATIC const mp_rom_map_elem_t machine_uart_locals_dict_table[] = {
+    // instance methods
+    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_uart_init_obj) },
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_uart_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_any), MP_ROM_PTR(&machine_uart_any_obj) },
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(machine_uart_locals_dict, machine_uart_locals_dict_table);
+
+mp_uint_t machine_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) {
+    machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    uint8_t *buf = buf_in;
+
+    if (size == 0) {
+        return 0;
+    }
+
+    if (!self->rx_fifo_buf) {
+        // no buffering
+        if (0 != tos_hal_uart_read(&self->uart, (const uint8_t *)buf, size, self->timeout + self->timeout_char * size)) {
+            return MP_STREAM_ERROR;
+        }
+        return size;
+    } else {
+        uint8_t *orig_buf = buf;
+        if (tos_chr_fifo_is_empty(&self->rx_fifo)) {
+            if (K_ERR_NONE != tos_sem_pend(&self->rx_sem, self->timeout)) {
+                *errcode = MP_EAGAIN;
+                return MP_STREAM_ERROR;
+            }
+        }
+        for (;;) {
+            int read_size = tos_chr_fifo_pop_stream(&self->rx_fifo, buf, size);
+            size -= read_size; buf += read_size;
+            if (size <= 0) {
+                return buf - orig_buf;
+            }
+            if (tos_chr_fifo_is_empty(&self->rx_fifo)) {
+                if (K_ERR_NONE != tos_sem_pend(&self->rx_sem, self->timeout_char)) {
+                    return buf - orig_buf;
+                }
+            }
+        }
+    }
+}
+
+mp_uint_t machine_uart_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
+    machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    int ret;
+
+    // tos_mutex_pend(&self->tx_lock);
+    ret = tos_hal_uart_write(&self->uart, (uint8_t *)buf, size, 0xFFFF);
+    // tos_mutex_post(&self->tx_lock);
+
+    if (ret != 0) {
+        return MP_STREAM_ERROR;
+    }
+
+    return size;
+}
+
+mp_uint_t machine_uart_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_uint_t ret;
+    if (request == MP_STREAM_POLL) {
+        uintptr_t flags = arg;
+        ret = 0;
+        if ((flags & MP_STREAM_POLL_RD) && !tos_chr_fifo_is_empty(&self->rx_fifo)) {
+            ret |= MP_STREAM_POLL_RD;
+        }
+        if ((flags & MP_STREAM_POLL_WR) && 1) {
+            ret |= MP_STREAM_POLL_WR;
+        }
+    } else {
+        *errcode = MP_EINVAL;
+        ret = MP_STREAM_ERROR;
+    }
+    return ret;
+}
+
+STATIC const mp_stream_p_t uart_stream_p = {
+    .read = machine_uart_read,
+    .write = machine_uart_write,
+    .ioctl = machine_uart_ioctl,
+    .is_text = false,
+};
+
+const mp_obj_type_t machine_uart_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_UART,
+    .print = machine_uart_print,
+    .make_new = machine_uart_make_new,
+    .getiter = mp_identity_getiter,
+    .iternext = mp_stream_unbuffered_iter,
+    .protocol = &uart_stream_p,
+    .locals_dict = (mp_obj_dict_t *)&machine_uart_locals_dict,
+};

components/language/micropython/port/modules/machine_uart.h

@@ -0,0 +1,56 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_MACHINE_UART_H
+#define MICROPY_INCLUDED_MACHINE_UART_H
+
+#include "py/obj.h"
+
+#ifndef MP_GEN_HDR
+#include "tos_k.h"
+#include "tos_hal.h"
+#include "tos_at.h"
+#endif
+
+extern const mp_obj_type_t machine_uart_type;
+
+typedef struct _machine_uart_obj_t machine_uart_obj_t;
+
+/* board */
+void mp_hal_uart_rx_start(uint32_t uart_id);
+void mp_hal_uart_irq_handler(uint32_t uart_id);
+
+/* repl */
+int machine_uart_rx_chr(machine_uart_obj_t *self);
+int machine_uart_tx_strn(machine_uart_obj_t *self, const char *str, mp_uint_t len);
+void machine_uart_rx_start(machine_uart_obj_t *self);
+void machine_uart_attach_to_repl(machine_uart_obj_t *self, uint8_t attached);
+
+/* esp8266 */
+void machine_uart_set_at_agent(machine_uart_obj_t *self, at_agent_t *at_agent);
+hal_uart_port_t machine_uart_get_port(machine_uart_obj_t *self);
+
+#endif /* MICROPY_INCLUDED_MACHINE_UART_H */

components/language/micropython/port/modules/modesp8266.c

@@ -0,0 +1,315 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+
+#if MICROPY_PY_NETWORK && MICROPY_PY_NETWORK_ESP8266
+
+#include "py/mphal.h"
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "py/stream.h"
+#include "py/mperrno.h"
+#include "extmod/modnetwork.h"
+#include "machine_uart.h"
+
+#if !(MP_GEN_HDR)
+#include "tos_k.h"
+#include "tos_at_socket.h"
+#include "sal_module_wrapper.h"
+#include "esp8266.h"
+#endif
+
+#define MAKE_SOCKADDR(addr, ip, port) \
+    struct sockaddr addr; \
+    addr.sa_family = AF_INET; \
+    addr.sa_data[0] = port >> 8; \
+    addr.sa_data[1] = port; \
+    addr.sa_data[2] = ip[0]; \
+    addr.sa_data[3] = ip[1]; \
+    addr.sa_data[4] = ip[2]; \
+    addr.sa_data[5] = ip[3];
+
+#define UNPACK_SOCKADDR(addr, ip, port) \
+    port = (addr.sa_data[0] << 8) | addr.sa_data[1]; \
+    ip[0] = addr.sa_data[2]; \
+    ip[1] = addr.sa_data[3]; \
+    ip[2] = addr.sa_data[4]; \
+    ip[3] = addr.sa_data[5];
+
+STATIC int esp8266_gethostbyname(mp_obj_t nic, const char *name, mp_uint_t len, uint8_t *ip_out) {
+    char ip_str[16];
+    if (0 != tos_sal_module_parse_domain(name, ip_str, sizeof(ip_str))) {
+        return -2;
+    }
+    int ret = sscanf(ip_str, "%hhu.%hhu.%hhu.%hhu", 
+        &ip_out[0], &ip_out[1], &ip_out[2], &ip_out[3]);
+    if (ret != 4) {
+        return -2;
+    }
+    return 0;
+}
+
+STATIC int socket_socket(struct _mod_network_socket_obj_t *skt, int *_errno) {
+    // only support IPv4
+    if (skt->domain != MOD_NETWORK_AF_INET) {
+        *_errno = MP_EAFNOSUPPORT;
+        return -1;
+    }
+    int domain = AF_INET;
+    
+    int type;
+    switch (skt->type) {
+        case MOD_NETWORK_SOCK_STREAM:
+            type = SOCK_STREAM;
+            break;
+        case MOD_NETWORK_SOCK_DGRAM:
+            type = SOCK_DGRAM;
+            break;
+        case MOD_NETWORK_SOCK_RAW:
+            // SOCK_RAW is not supported yet
+        default:
+            *_errno = MP_EINVAL;
+            return -1;            
+    }
+
+    // open socket
+    int fd = socket(domain, type, 0);
+    if (fd < 0) {
+        // FIXME: no more detailed errno
+        *_errno = MP_EMFILE;
+        return -1;
+    }
+
+    // store state of this socket
+    skt->fileno = fd;
+
+    return 0;
+}
+
+STATIC void socket_close(struct _mod_network_socket_obj_t *socket) {
+    close(socket->fileno);
+}
+
+STATIC int socket_bind(struct _mod_network_socket_obj_t *socket, byte *ip, mp_uint_t port, int *_errno) {
+    // FIXME: not support
+    *_errno = MP_EINVAL;
+    return -1;
+}
+
+STATIC int socket_listen(struct _mod_network_socket_obj_t *socket, mp_int_t backlog, int *_errno) {
+    // FIXME: not support
+    *_errno = MP_EINVAL;
+    return -1;
+}
+
+STATIC int socket_accept(struct _mod_network_socket_obj_t *socket, struct _mod_network_socket_obj_t *socket2, byte *ip, mp_uint_t *port, int *_errno) {
+    // FIXME: not support
+    *_errno = MP_EINVAL;
+    return -1;
+}
+
+STATIC int socket_connect(struct _mod_network_socket_obj_t *socket, byte *ip, mp_uint_t port, int *_errno) {
+    MAKE_SOCKADDR(addr, ip, port);
+    int ret = connect(socket->fileno, &addr, sizeof(addr));
+    if (ret != 0) {
+        // FIXME: no more detailed errno
+        *_errno = MP_ETIMEDOUT;
+        return -1;
+    }
+    return 0;
+}
+
+STATIC mp_uint_t socket_send(struct _mod_network_socket_obj_t *socket, const byte *buf, mp_uint_t len, int *_errno) {
+    int ret = send(socket->fileno, buf, len, 0);
+    if (ret < 0) {
+        // FIXME: no more detailed errno
+        *_errno = MP_EPERM;
+        return (mp_uint_t)-1;
+    }
+    return ret;
+}
+
+STATIC mp_uint_t socket_recv(struct _mod_network_socket_obj_t *socket, byte *buf, mp_uint_t len, int *_errno) {
+    int ret = recv(socket->fileno, buf, len, 0);
+    if (ret < 0) {
+        // FIXME: no more detailed errno
+        *_errno = MP_EPERM;
+        return (mp_uint_t)-1;
+    }
+    return ret;
+}
+
+STATIC mp_uint_t socket_sendto(struct _mod_network_socket_obj_t *socket, const byte *buf, mp_uint_t len, byte *ip, mp_uint_t port, int *_errno) {
+    MAKE_SOCKADDR(addr, ip, port);
+    int ret = sendto(socket->fileno, buf, len, 0, &addr, sizeof(addr));
+    if (ret < 0) {
+        // FIXME: no more detailed errno
+        *_errno = MP_EPERM;
+        return (mp_uint_t)-1;
+    }
+    return ret;
+}
+
+STATIC mp_uint_t socket_recvfrom(struct _mod_network_socket_obj_t *socket, byte *buf, mp_uint_t len, byte *ip, mp_uint_t *port, int *_errno) {
+    struct sockaddr addr;
+    socklen_t addr_len = sizeof(addr);
+    int ret = recvfrom(socket->fileno, buf, len, 0, &addr, &addr_len);
+    if (ret < 0) {
+        // FIXME
+        *_errno = MP_EPERM;
+        return (mp_uint_t)-1;
+    }
+    UNPACK_SOCKADDR(addr, ip, *port);
+    return ret;
+}
+
+STATIC int socket_setsockopt(struct _mod_network_socket_obj_t *socket, mp_uint_t level, mp_uint_t opt, const void *optval, mp_uint_t optlen, int *_errno) {
+    // FIXME not support
+    *_errno = MP_EINVAL;
+    return -1;
+}
+
+STATIC int socket_settimeout(struct _mod_network_socket_obj_t *socket, mp_uint_t timeout_ms, int *_errno) {
+    // FIXME
+    *_errno = MP_EINVAL;
+    return -1;
+}
+
+STATIC int socket_ioctl(struct _mod_network_socket_obj_t *socket, mp_uint_t request, mp_uint_t arg, int *_errno) {
+    // FIXME
+    if (request == MP_STREAM_POLL) {
+        int ret = 0;
+        if ((arg & MP_STREAM_POLL_RD) && 1) {
+            ret |= MP_STREAM_POLL_RD;
+        }
+        if ((arg & MP_STREAM_POLL_WR) && 1) {
+            ret |= MP_STREAM_POLL_WR;
+        }
+        return ret;
+    } else {
+        *_errno = MP_EINVAL;
+        return (int)MP_STREAM_ERROR;
+    }
+}
+
+/********************************************/
+typedef struct _esp8266_obj_t {
+    mp_obj_base_t base;
+    const machine_uart_obj_t *uart;
+    uint8_t init;
+} esp8266_obj_t;
+
+STATIC esp8266_obj_t esp8266_obj = {
+    {(mp_obj_type_t *)&mod_network_nic_type_esp8266}, 
+    .uart = NULL,
+    .init = 0,
+};
+
+extern at_agent_t esp8266_agent;
+STATIC mp_obj_t esp8266_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    // check arguments
+    mp_arg_check_num(n_args, n_kw, 1, 1, false);
+
+    if (!esp8266_obj.init) {
+        machine_uart_obj_t *uart = MP_OBJ_TO_PTR(args[0]);
+        machine_uart_set_at_agent(uart, &esp8266_agent);
+        machine_uart_rx_start(uart);
+        if (0 != esp8266_sal_init(machine_uart_get_port(uart))) {
+				    esp8266_sal_deinit();
+            machine_uart_set_at_agent(uart, NULL);
+            mp_raise_msg(&mp_type_OSError, "can't setup esp8266");
+        }
+
+        esp8266_obj.uart = uart;
+        esp8266_obj.init = 1;
+
+        mod_network_register_nic(MP_OBJ_FROM_PTR(&esp8266_obj));
+    }
+
+    return MP_OBJ_FROM_PTR(&esp8266_obj);
+}
+
+STATIC mp_obj_t esp8266_connect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_ssid, ARG_pwd };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_ssid, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_pwd, MP_ARG_OBJ, {.u_obj = mp_const_none} },
+    };
+
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // get ssid
+    size_t ssid_len;
+    const char *ssid = mp_obj_str_get_data(args[ARG_ssid].u_obj, &ssid_len);
+
+    // get pwd
+    size_t pwd_len = 0;
+    const char *pwd = "";
+    if (args[ARG_pwd].u_obj != mp_const_none) {
+        pwd = mp_obj_str_get_data(args[ARG_pwd].u_obj, &pwd_len);
+    }
+
+    // connect to AP
+    if (esp8266_join_ap(ssid, pwd) != 0) {
+        mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("could not connect to ssid=%s, pwd=%s\n"), ssid, pwd);
+    }
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp8266_connect_obj, 1, esp8266_connect);
+
+STATIC const mp_rom_map_elem_t esp8266_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&esp8266_connect_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(esp8266_locals_dict, esp8266_locals_dict_table);
+
+const mod_network_nic_type_t mod_network_nic_type_esp8266 = {
+    .base = {
+        { &mp_type_type },
+        .name = MP_QSTR_ESP8266,
+        .make_new = esp8266_make_new,
+        .locals_dict = (mp_obj_dict_t *)&esp8266_locals_dict,
+    },
+    .gethostbyname = esp8266_gethostbyname,
+    .socket = socket_socket,
+    .close = socket_close,
+    .bind = socket_bind,
+    .listen = socket_listen,
+    .accept = socket_accept,
+    .connect = socket_connect,
+    .send = socket_send,
+    .recv = socket_recv,
+    .sendto = socket_sendto,
+    .recvfrom = socket_recvfrom,
+    .setsockopt = socket_setsockopt,
+    .settimeout = socket_settimeout,
+    .ioctl = socket_ioctl,
+};
+
+#endif /* MICROPY_PY_NETWORK && MICROPY_PY_NETWORK_ESP8266*/

components/language/micropython/port/modules/modmachine.c

@@ -0,0 +1,80 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+
+#if MICROPY_PY_MACHINE
+
+#include "py/runtime.h"
+#include "shared/runtime/pyexec.h"
+#include "extmod/machine_mem.h"
+#include "extmod/machine_signal.h"
+#include "extmod/machine_spi.h"
+#include "extmod/machine_i2c.h"
+#include "modmachine.h"
+
+STATIC mp_obj_t machine_soft_reset(void) {
+    pyexec_system_exit = PYEXEC_FORCED_EXIT;
+    mp_raise_type(&mp_type_SystemExit);
+}
+MP_DEFINE_CONST_FUN_OBJ_0(machine_soft_reset_obj, machine_soft_reset);
+
+STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_umachine) },
+
+    { MP_ROM_QSTR(MP_QSTR_soft_reset), MP_ROM_PTR(&machine_soft_reset_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) },
+
+    { MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&machine_pin_type) },
+    { MP_ROM_QSTR(MP_QSTR_Signal), MP_ROM_PTR(&machine_signal_type) },
+
+    #if MICROPY_PY_MACHINE_I2C
+    #if MICROPY_PY_MACHINE_SOFTI2C
+    { MP_ROM_QSTR(MP_QSTR_SoftI2C), MP_ROM_PTR(&mp_machine_soft_i2c_type) },
+    #endif
+    #endif
+    #if MICROPY_PY_MACHINE_SPI
+    { MP_ROM_QSTR(MP_QSTR_SPI), MP_ROM_PTR(&machine_hard_spi_type) },
+    #if MICROPY_PY_MACHINE_SOFTSPI
+    { MP_ROM_QSTR(MP_QSTR_SoftSPI), MP_ROM_PTR(&mp_machine_soft_spi_type) },
+    #endif
+    #endif
+
+    { MP_ROM_QSTR(MP_QSTR_UART), MP_ROM_PTR(&machine_uart_type) },
+    { MP_ROM_QSTR(MP_QSTR_Timer), MP_ROM_PTR(&machine_timer_type) },
+};
+STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table);
+
+const mp_obj_module_t mp_module_machine = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&machine_module_globals,
+};
+MP_REGISTER_MODULE(MP_QSTR_umachine, mp_module_machine);
+
+#endif /* MICROPY_PY_MACHINE */

components/language/micropython/port/modules/modmachine.h

@@ -0,0 +1,37 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_MODMACHINE_H
+#define MICROPY_INCLUDED_MODMACHINE_H
+
+#include "py/obj.h"
+
+#include "machine_pin.h"
+#include "machine_uart.h"
+#include "machine_hw_spi.h"
+#include "machine_timer.h"
+
+#endif /* MICROPY_INCLUDED_MODMACHINE_H */

components/language/micropython/port/modules/modutime.c

@@ -0,0 +1,64 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+
+#if MICROPY_PY_UTIME
+
+#include "py/runtime.h"
+#include "py/smallint.h"
+#include "py/obj.h"
+#include "shared/timeutils/timeutils.h"
+#include "extmod/utime_mphal.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_gmtime), MP_ROM_PTR(&time_localtime_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_localtime), MP_ROM_PTR(&time_localtime_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_mktime), MP_ROM_PTR(&time_mktime_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&time_time_obj) },
+    { 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) },
+    // { MP_ROM_QSTR(MP_QSTR_time_ns), MP_ROM_PTR(&mp_utime_time_ns_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(time_module_globals, time_module_globals_table);
+
+const mp_obj_module_t mp_module_utime = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&time_module_globals,
+};
+
+MP_REGISTER_MODULE(MP_QSTR_utime, mp_module_utime);
+
+#endif /* MICROPY_PY_UTIME */

components/language/micropython/port/modules/vfs_tos.c

@@ -0,0 +1,361 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+
+#if MICROPY_VFS_TOS
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+#include "py/mphal.h"
+#include "py/mpthread.h"
+#include "extmod/vfs.h"
+#include "vfs_tos.h"
+#if !(MP_GEN_HDR)
+#include "tos_vfs.h"
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+typedef struct _mp_obj_vfs_tos_t {
+    mp_obj_base_t base;
+    vstr_t root;
+    size_t root_len;
+    bool readonly;
+} mp_obj_vfs_tos_t;
+
+// It's a nice trick for reducing memory reallocation to add `path` after `self->root` directly rather create a new vstr.
+// But it's not so useful on repeated calling (e.g. rename).
+STATIC const char *vfs_tos_get_path_str(mp_obj_vfs_tos_t *self, mp_obj_t path) {
+    if (self->root_len == 0) {
+        return mp_obj_str_get_str(path);
+    } else {
+        self->root.len = self->root_len;
+        vstr_add_str(&self->root, mp_obj_str_get_str(path));
+        return vstr_null_terminated_str(&self->root);
+    }
+}
+
+STATIC mp_obj_t vfs_tos_get_path_obj(mp_obj_vfs_tos_t *self, mp_obj_t path) {
+    if (self-> root_len == 0) {
+        return path;
+    } else {
+        self->root.len = self->root_len;
+        vstr_add_str(&self->root, mp_obj_str_get_str(path));
+        return mp_obj_new_str(self->root.buf, self->root.len);
+    }
+}
+
+STATIC mp_import_stat_t mp_vfs_tos_import_stat(void *self_in, const char *path) {
+    mp_obj_vfs_tos_t *self = self_in;
+    if (self->root_len != 0) {
+        self->root.len = self->root_len;
+        vstr_add_str(&self->root, path);
+        path = vstr_null_terminated_str(&self->root);
+    }
+    vfs_fstat_t st;
+    int ret = tos_vfs_stat(path, &st);
+    if (ret == 0) {
+        if (st.type == VFS_TYPE_DIRECTORY) {
+            return MP_IMPORT_STAT_DIR;
+        } else if (st.type == VFS_TYPE_FILE) {
+            return MP_IMPORT_STAT_FILE;
+        }
+    }
+    return MP_IMPORT_STAT_NO_EXIST;
+}
+
+STATIC mp_obj_t vfs_tos_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, 0, 1, false);
+
+    mp_obj_vfs_tos_t *vfs = mp_obj_malloc(mp_obj_vfs_tos_t, type);
+    vstr_init(&vfs->root, 0);
+    if (n_args == 1) {
+        vstr_add_str(&vfs->root, mp_obj_str_get_str(args[0]));
+        vstr_add_char(&vfs->root, '/');
+    }
+    vfs->root_len = vfs->root.len;
+    vfs->readonly = false;
+
+    return MP_OBJ_FROM_PTR(vfs);
+}
+
+STATIC mp_obj_t vfs_tos_mount(mp_obj_t self_in, mp_obj_t readonly, mp_obj_t mkfs) {
+    mp_obj_vfs_tos_t *self = MP_OBJ_TO_PTR(self_in);
+    if (mp_obj_is_true(readonly)) {
+        self->readonly = true;
+    }
+    if (mp_obj_is_true(mkfs)) {
+        mp_raise_OSError(MP_EPERM);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(vfs_tos_mount_obj, vfs_tos_mount);
+
+STATIC mp_obj_t vfs_tos_umount(mp_obj_t self_in) {
+    (void)self_in;
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(vfs_tos_umount_obj, vfs_tos_umount);
+
+STATIC mp_obj_t vfs_tos_open(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mode_in) {
+    mp_obj_vfs_tos_t *self = MP_OBJ_TO_PTR(self_in);
+    const char *mode = mp_obj_str_get_str(mode_in);
+    if (self->readonly
+        && (strchr(mode, 'w') != NULL || strchr(mode, 'a') != NULL || strchr(mode, '+') != NULL)) {
+        mp_raise_OSError(MP_EROFS);
+    }
+    if (!mp_obj_is_small_int(path_in)) {
+        path_in = vfs_tos_get_path_obj(self, path_in);
+    }
+    return mp_vfs_tos_file_open(&mp_type_textio, path_in, mode_in);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(vfs_tos_open_obj, vfs_tos_open);
+
+STATIC mp_obj_t vfs_tos_chdir(mp_obj_t self_in, mp_obj_t path_in) {
+    // FIXME chdir() is not supported by tos
+    mp_raise_OSError(MP_EPERM);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_tos_chdir_obj, vfs_tos_chdir);
+
+STATIC mp_obj_t vfs_tos_getcwd(mp_obj_t self_in) {
+    // FIXME getcwd() is not supported by tos
+    return mp_obj_new_str("/", 1);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(vfs_tos_getcwd_obj, vfs_tos_getcwd);
+
+typedef struct _vfs_tos_ilistdir_it_t {
+    mp_obj_base_t base;
+    mp_fun_1_t iternext;
+    bool is_str;
+    VFS_DIR *dir;
+} vfs_tos_ilistdir_it_t;
+
+STATIC mp_obj_t vfs_tos_ilistdir_it_iternext(mp_obj_t self_in) {
+    vfs_tos_ilistdir_it_t *self = MP_OBJ_FROM_PTR(self_in);
+
+    if (self->dir == NULL) {
+        return MP_OBJ_STOP_ITERATION;
+    }
+
+    for (;;) {
+        vfs_dirent_t *dirent = tos_vfs_readdir(self->dir);
+        if (dirent == NULL) {
+            tos_vfs_closedir(self->dir);
+            self->dir = NULL;
+            return MP_OBJ_STOP_ITERATION;
+        }
+        const char *fn = dirent->name;
+
+        if (fn[0] == '.' && (fn[1] == 0 || fn[1] == '.')) {
+            // skip . and ..
+            continue;
+        }
+
+        // make 3-tuple with info about this entry
+        mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
+
+        if (self->is_str) {
+            t->items[0] = mp_obj_new_str(fn, strlen(fn));
+        } else {
+            t->items[0] = mp_obj_new_bytes((const byte *)fn, strlen(fn));
+        }
+
+        if (dirent->type == VFS_TYPE_DIRECTORY) {
+            t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFDIR);
+        } else if (dirent->type == VFS_TYPE_FILE) {
+            t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFREG);
+        } else {
+            // unknown type should be 0
+            t->items[1] = MP_OBJ_NEW_SMALL_INT(0);
+        }
+
+        // ino is not supported by tos
+        t->items[2] = MP_OBJ_NEW_SMALL_INT(0);
+
+        return MP_OBJ_FROM_PTR(t);
+    }
+}
+
+STATIC mp_obj_t vfs_tos_ilistdir(mp_obj_t self_in, mp_obj_t path_in) {
+    mp_obj_vfs_tos_t *self = MP_OBJ_TO_PTR(self_in);
+    vfs_tos_ilistdir_it_t *iter = mp_obj_malloc(vfs_tos_ilistdir_it_t, &mp_type_polymorph_iter);
+    iter->iternext = vfs_tos_ilistdir_it_iternext;
+    iter->is_str = mp_obj_get_type(path_in) == &mp_type_str;
+    const char *path = vfs_tos_get_path_str(self, path_in);
+    if (path[0] == '\0') {
+        path = ".";
+    }
+    iter->dir = tos_vfs_opendir(path);
+    if (iter->dir == NULL) {
+        // mp_raise_OSError(errno)
+        return mp_const_none;
+    }
+    return MP_OBJ_FROM_PTR(iter);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_tos_ilistdir_obj, vfs_tos_ilistdir);
+
+STATIC mp_obj_t vfs_tos_mkdir(mp_obj_t self_in, mp_obj_t path_in) {
+    mp_obj_vfs_tos_t *self = MP_OBJ_TO_PTR(self_in);
+    const char *path = vfs_tos_get_path_str(self, path_in);
+    int ret = tos_vfs_mkdir(path);
+    if (ret != 0) {
+        mp_raise_OSError(vfs_err_to_errno_table[-ret]);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_tos_mkdir_obj, vfs_tos_mkdir);
+
+STATIC mp_obj_t vfs_tos_remove(mp_obj_t self_in, mp_obj_t path_in) {
+    mp_obj_vfs_tos_t *self = MP_OBJ_TO_PTR(self_in);
+    const char *path = vfs_tos_get_path_str(self, path_in);
+    int ret = tos_vfs_unlink(path);
+    if (ret != 0) {
+        mp_raise_OSError(vfs_err_to_errno_table[-ret]);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_tos_remove_obj, vfs_tos_remove);
+
+STATIC mp_obj_t vfs_tos_rename(mp_obj_t self_in, mp_obj_t old_path_in, mp_obj_t new_path_in) {
+    mp_obj_vfs_tos_t *self = MP_OBJ_TO_PTR(self_in);
+    const char *old_path = vfs_tos_get_path_str(self, old_path_in);
+    // const char *new_path = vfs_tos_get_path_str(self, new_path_in);
+    const char *new_path = mp_obj_str_get_str(new_path_in);
+    vstr_t *new_path_vstr = NULL;
+    if (self->root_len != 0) {
+        int new_path_len = strlen(new_path);
+        new_path_vstr = vstr_new(self->root_len + new_path_len);
+        vstr_add_strn(new_path_vstr, self->root.buf, self->root_len);
+        vstr_add_strn(new_path_vstr, new_path, new_path_len);
+        new_path = vstr_null_terminated_str(new_path_vstr);
+    }
+
+    int ret = tos_vfs_rename(old_path, new_path);
+    if (new_path_vstr) { vstr_free(new_path_vstr); }
+    if (ret != 0) {
+        mp_raise_OSError(vfs_err_to_errno_table[-ret]);
+    }
+    return mp_const_none;
+    
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(vfs_tos_rename_obj, vfs_tos_rename);
+
+STATIC mp_obj_t vfs_tos_rmdir(mp_obj_t self_in, mp_obj_t path_in) {
+    mp_obj_vfs_tos_t *self = MP_OBJ_TO_PTR(self_in);
+    const char *path = vfs_tos_get_path_str(self, path_in);
+    // FIXME: rmdir is not supported by fatfs
+    int ret = tos_vfs_rmdir(path);
+    if (ret != 0) {
+        mp_raise_OSError(vfs_err_to_errno_table[-ret]);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_tos_rmdir_obj, vfs_tos_rmdir);
+
+STATIC mp_obj_t vfs_tos_stat(mp_obj_t self_in, mp_obj_t path_in) {
+    mp_obj_vfs_tos_t *self = MP_OBJ_TO_PTR(self_in);
+    vfs_fstat_t st;
+    const char *path = vfs_tos_get_path_str(self, path_in);
+    int ret = tos_vfs_stat(path, &st);
+    if (ret != 0) {
+        mp_raise_OSError(vfs_err_to_errno_table[-ret]);
+    }
+    mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
+    t->items[0] = MP_OBJ_NEW_SMALL_INT(st.mode);
+    t->items[1] = mp_obj_new_int_from_uint(0); // st_ino
+    t->items[2] = mp_obj_new_int_from_uint(0); // st_dev
+    t->items[3] = mp_obj_new_int_from_uint(0); // st_nlink
+    t->items[4] = mp_obj_new_int_from_uint(0); // st_uid
+    t->items[5] = mp_obj_new_int_from_uint(0); // st_gid
+    t->items[6] = mp_obj_new_int_from_uint(st.size); // st_size
+    t->items[7] = mp_obj_new_int_from_uint(st.atime); // st_atime
+    t->items[8] = mp_obj_new_int_from_uint(st.mtime); // st_mtime
+    t->items[9] = mp_obj_new_int_from_uint(st.ctime); // st_ctime
+    return MP_OBJ_FROM_PTR(t);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_tos_stat_obj, vfs_tos_stat);
+
+#if MICROPY_PY_UOS_STATVFS
+STATIC mp_obj_t vfs_tos_statvfs(mp_obj_t self_in, mp_obj_t path_in) {
+    mp_obj_vfs_tos_t *self = MP_OBJ_TO_PTR(self_in);
+    vfs_fsstat_t st;
+    const char *path = vfs_tos_get_path_str(self, path_in);
+    int ret = tos_vfs_statfs(path, &st);
+    if (ret != 0) {
+        mp_raise_OSError(vfs_err_to_errno_table[-ret]);
+    }
+    mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
+    t->items[0] = MP_OBJ_NEW_SMALL_INT(st.blk_size); // f_bsize
+    t->items[1] = MP_OBJ_NEW_SMALL_INT(st.blk_size); // f_frsize
+    t->items[2] = MP_OBJ_NEW_SMALL_INT(st.blk_num); // f_blocks
+    t->items[3] = MP_OBJ_NEW_SMALL_INT(st.blk_free); // f_bfree
+    t->items[4] = MP_OBJ_NEW_SMALL_INT(st.blk_avail); // f_bavail
+    t->items[5] = MP_OBJ_NEW_SMALL_INT(st.file_num); // f_files
+    t->items[6] = MP_OBJ_NEW_SMALL_INT(st.file_free); // f_ffree
+    t->items[7] = MP_OBJ_NEW_SMALL_INT(st.file_free); // f_favail
+    t->items[8] = MP_OBJ_NEW_SMALL_INT(0); // f_flags
+    t->items[9] = MP_OBJ_NEW_SMALL_INT(st.name_len); // f_namemax
+    return MP_OBJ_FROM_PTR(t);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_tos_statvfs_obj, vfs_tos_statvfs);
+
+
+#endif /* MICROPY_PY_UOS_STATVFS */
+
+STATIC const mp_rom_map_elem_t vfs_tos_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_mount), MP_ROM_PTR(&vfs_tos_mount_obj) },
+    { MP_ROM_QSTR(MP_QSTR_umount), MP_ROM_PTR(&vfs_tos_umount_obj) },
+    { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&vfs_tos_open_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_chdir), MP_ROM_PTR(&vfs_tos_chdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_getcwd), MP_ROM_PTR(&vfs_tos_getcwd_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ilistdir), MP_ROM_PTR(&vfs_tos_ilistdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mkdir), MP_ROM_PTR(&vfs_tos_mkdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&vfs_tos_remove_obj) },
+    { MP_ROM_QSTR(MP_QSTR_rename), MP_ROM_PTR(&vfs_tos_rename_obj) },
+    { MP_ROM_QSTR(MP_QSTR_rmdir), MP_ROM_PTR(&vfs_tos_rmdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_stat), MP_ROM_PTR(&vfs_tos_stat_obj) },
+    #if MICROPY_PY_UOS_STATVFS
+    { MP_ROM_QSTR(MP_QSTR_statvfs), MP_ROM_PTR(&vfs_tos_statvfs_obj) },
+    #endif
+};
+STATIC MP_DEFINE_CONST_DICT(vfs_tos_locals_dict, vfs_tos_locals_dict_table);
+
+STATIC const mp_vfs_proto_t vfs_tos_proto = {
+    .import_stat = mp_vfs_tos_import_stat,
+};
+
+const mp_obj_type_t mp_type_vfs_tos = {
+    { &mp_type_type },
+    .name = MP_QSTR_VfsTos,
+    .make_new = vfs_tos_make_new,
+    .protocol = &vfs_tos_proto,
+    .locals_dict = (mp_obj_dict_t *)&vfs_tos_locals_dict,
+};
+
+#endif /* MICROPY_VFS_TOS */

components/language/micropython/port/modules/vfs_tos.h

@@ -0,0 +1,39 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_VFS_TOS_H
+#define MICROPY_INCLUDED_VFS_TOS_H
+
+#include "py/obj.h"
+
+extern const byte vfs_err_to_errno_table[22];
+extern const mp_obj_type_t mp_type_vfs_tos;
+extern const mp_obj_type_t mp_type_vfs_tos_fileio;
+extern const mp_obj_type_t mp_type_vfs_tos_textio;
+
+mp_obj_t mp_vfs_tos_file_open(const mp_obj_type_t *type, mp_obj_t file_in, mp_obj_t mode_in);
+
+#endif /* MICROPY_INCLUDED_VFS_TOS_H */

components/language/micropython/port/modules/vfs_tos_file.c

@@ -0,0 +1,321 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+
+#if MICROPY_VFS_TOS
+
+#include "py/mphal.h"
+#include "py/mpthread.h"
+#include "py/runtime.h"
+#include "py/stream.h"
+#include "vfs_tos.h"
+#include "unistd.h"
+#if !(MP_GEN_HDR)
+#include "tos_vfs.h"
+#endif
+
+const byte vfs_err_to_errno_table[] = {
+    [VFS_ERR_NONE] = 0,
+    [VFS_ERR_BUFFER_NULL] = MP_EINVAL,
+    [VFS_ERR_DEVICE_NOT_REGISTERED] = MP_ENODEV,
+    [VFS_ERR_DEVICE_ALREADY_REGISTERED] = 0, // should never be here
+    [VFS_ERR_FILE_NO_AVAILABLE] = MP_EACCES,
+    [VFS_ERR_FILE_NOT_OPEN] = MP_EBADF,
+    [VFS_ERR_FS_ALREADY_MOUNTED] = 0, // should never be here
+    [VFS_ERR_FS_ALREADY_REGISTERED] = 0, // should never be here
+    [VFS_ERR_FS_NOT_REGISTERED] = MP_ENODEV,
+    [VFS_ERR_FS_NOT_MOUNT] = MP_ENODEV,
+    [VFS_ERR_OPS_NULL] = MP_ENODEV,
+    [VFS_ERR_OPS_FAILED] = MP_ENODEV,
+    [VFS_ERR_INODE_NAME_TOO_LONG] = MP_EINVAL,
+    [VFS_ERR_INODE_CREATE_FAILED] = MP_ENOMEM,
+    [VFS_ERR_INODE_NOT_FOUND] = MP_ENOENT,
+    [VFS_ERR_INODE_INVALID] = MP_ENOENT,
+    [VFS_ERR_INODE_BUSY] = MP_EBUSY,
+    [VFS_ERR_INODE_INAVALIABLE] = MP_ENOENT,
+    [VFS_ERR_OPEN_DIR] = MP_EISDIR, // not used
+    [VFS_ERR_OUT_OF_MEMORY] = MP_ENOMEM,
+    [VFS_ERR_PARA_INVALID] = MP_EINVAL,
+    [VFS_ERR_PATH_TOO_LONG] = MP_EINVAL,
+};
+
+typedef struct _mp_obj_vfs_tos_file_t {
+    mp_obj_base_t base;
+    int fd;
+} mp_obj_vfs_tos_file_t;
+
+#if MICROPY_CPYTHON_COMPAT
+STATIC void check_fd_is_open(const mp_obj_vfs_tos_file_t *o) {
+    if (o->fd < 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("I/O operation on closed file"));
+    }
+}
+#else
+#define check_fd_is_open(o)
+#endif
+
+STATIC void vfs_tos_file_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    (void)kind;
+    mp_obj_vfs_tos_file_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_printf(print, "<io.%s %d>", mp_obj_get_type_str(self_in), self->fd);
+}
+
+mp_obj_t mp_vfs_tos_file_open(const mp_obj_type_t *type, mp_obj_t file_in, mp_obj_t mode_in) {
+    // [REF] vfs_posix_file.c > mp_vfs_posix_file_open
+    // [REF] vfs_fat_file.c > mp_vfs_fat_file_open
+    mp_obj_vfs_tos_file_t *o = m_new_obj(mp_obj_vfs_tos_file_t);
+    const char *mode_s = mp_obj_str_get_str(mode_in);
+
+    int mode = 0;
+    while (*mode_s) {
+        switch (*mode_s++) {
+            case 'r':
+                mode |= VFS_OFLAG_READ;
+                break;
+            case 'w':
+                mode |= VFS_OFLAG_WRITE | VFS_OFLAG_CREATE_ALWAYS;
+                break;
+            case 'x':
+                mode |= VFS_OFLAG_WRITE | VFS_OFLAG_CREATE_NEW;
+                break;
+            case 'a':
+                mode |= VFS_OFLAG_WRITE | VFS_OFLAG_OPEN_ALWAYS; // FIXME: VFS_OFLAG_OPEN_APPEND ?
+                break;
+            case '+':
+                mode |= VFS_OFLAG_READ | VFS_OFLAG_WRITE;
+                break;
+            #if MICROPY_PY_IO_FILEIO
+            // If we don't have io.FileIO, then files are in text mode implicitly
+            case 'b':
+                type = &mp_type_vfs_tos_fileio;
+                break;
+            case 't':
+                type = &mp_type_vfs_tos_textio;
+                break;
+            #endif /* MICROPY_PY_IO_FILEIO */
+        }
+    }
+
+    o->base.type = type;
+
+    mp_obj_t fid = file_in;
+
+    if (mp_obj_is_small_int(fid)) {
+        o->fd = MP_OBJ_SMALL_INT_VALUE(fid);
+        return MP_OBJ_FROM_PTR(o);
+    }
+
+    const char *fname = mp_obj_str_get_str(fid);
+    int r = tos_vfs_open(fname, mode);
+    if (r < 0) {
+        mp_raise_OSError(vfs_err_to_errno_table[-r]);
+    }
+    o->fd = r;
+    return MP_OBJ_FROM_PTR(o);
+}
+
+STATIC mp_obj_t vfs_tos_file_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    // [REF] vfs_posix_file.c > vfs_posix_file_make_new
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_mode, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR_r)} },
+    };
+
+    mp_arg_val_t arg_vals[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all_kw_array(n_args, n_kw, args, MP_ARRAY_SIZE(allowed_args), allowed_args, arg_vals);
+    return mp_vfs_tos_file_open(type, arg_vals[0].u_obj, arg_vals[1].u_obj);
+}
+
+STATIC mp_obj_t vfs_tos_file_fileno(mp_obj_t self_in) {
+    mp_obj_vfs_tos_file_t *self = MP_OBJ_TO_PTR(self_in);
+    check_fd_is_open(self);
+    return MP_OBJ_NEW_SMALL_INT(self->fd);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(vfs_tos_file_fileno_obj, vfs_tos_file_fileno);
+
+STATIC mp_obj_t vfs_tos_file___exit__(size_t n_args, const mp_obj_t *args) {
+    (void)n_args;
+    return mp_stream_close(args[0]);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(vfs_tos_file___exit___obj, 4, 4, vfs_tos_file___exit__);
+
+STATIC mp_uint_t vfs_tos_file_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
+    // [REF] vfs_posix_file.c > vfs_posix_file_read
+    mp_obj_vfs_tos_file_t *o = MP_OBJ_TO_PTR(o_in);
+    check_fd_is_open(o);
+    int r = tos_vfs_read(o->fd, buf, size);
+    if (r < 0) {
+        *errcode = vfs_err_to_errno_table[-r];
+        return MP_STREAM_ERROR;
+    }
+    return (mp_uint_t)r;
+}
+
+STATIC mp_uint_t vfs_tos_file_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
+    // [REF] vfs_posix_file.c > vfs_posix_file_write
+    mp_obj_vfs_tos_file_t *o = MP_OBJ_TO_PTR(o_in);
+    check_fd_is_open(o);
+    #if MICROPY_PY_OS_DUPTERM
+    // FIXME: not supported
+    if (o->fd <= STDERR_FILENO) {
+        mp_hal_stdout_tx_strn(buf, size);
+        return size;
+    }
+    #endif /* MICROPY_PY_OS_DUPTERM */
+    int r = tos_vfs_write(o->fd, buf, size);
+    if (r < 0) {
+        *errcode = vfs_err_to_errno_table[-r];
+        return MP_STREAM_ERROR;
+    }
+    return (mp_uint_t)r;
+}
+
+STATIC mp_uint_t vfs_tos_file_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    // [REF] vfs_posix_file.c > vfs_posix_file_ioctl
+    mp_obj_vfs_tos_file_t *o = MP_OBJ_TO_PTR(o_in);
+
+    if (request != MP_STREAM_CLOSE) {
+        check_fd_is_open(o);
+    }
+
+    switch (request) {
+        case MP_STREAM_FLUSH: {
+            int r = tos_vfs_sync(o->fd);
+            if (r < 0) {
+                *errcode = vfs_err_to_errno_table[-r];
+                return MP_STREAM_ERROR;
+            }
+            return 0;
+        }
+        case MP_STREAM_SEEK: {
+            struct mp_stream_seek_t *s = (struct mp_stream_seek_t *)arg;
+            int r = tos_vfs_lseek(o->fd, s->offset, s->whence);
+            if (r < 0) {
+                *errcode = vfs_err_to_errno_table[-r];
+                return MP_STREAM_ERROR;
+            }
+            s->offset = r;
+            return 0;
+        }
+        case MP_STREAM_CLOSE: {
+            int r = tos_vfs_close(o->fd);
+            if (r < 0) {
+                *errcode = vfs_err_to_errno_table[-r];
+                return MP_STREAM_ERROR;
+            }
+            #if MICROPY_CPYTHON_COMPAT
+            o->fd = -1;
+            #endif
+            return 0;
+        }
+        case MP_STREAM_GET_FILENO:
+            return o->fd;
+        #if MICROPY_PY_USELECT
+        case MP_STREAM_POLL: {
+            mp_raise_NotImplementedError(MP_ERROR_TEXT("poll on file not available on TencentOS-tiny"));
+        }
+        #endif
+        default:
+            *errcode = MP_EINVAL;
+            return MP_STREAM_ERROR;
+    }
+}
+
+STATIC const mp_rom_map_elem_t vfs_tos_rawfile_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_fileno), MP_ROM_PTR(&vfs_tos_file_fileno_obj) },
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readlines), MP_ROM_PTR(&mp_stream_unbuffered_readlines_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
+    { MP_ROM_QSTR(MP_QSTR_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
+    { MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
+    { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&mp_stream_flush_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&mp_identity_obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&vfs_tos_file___exit___obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(vfs_tos_rawfile_locals_dict, vfs_tos_rawfile_locals_dict_table);
+
+#if MICROPY_PY_IO_FILEIO
+STATIC const mp_stream_p_t vfs_tos_fileio_stream_p = {
+    .read = vfs_tos_file_read,
+    .write = vfs_tos_file_write,
+    .ioctl = vfs_tos_file_ioctl,
+};
+
+const mp_obj_type_t mp_type_vfs_tos_fileio = {
+    { &mp_type_type },
+    .name = MP_QSTR_FileIO,
+    .print = vfs_tos_file_print,
+    .make_new = vfs_tos_file_make_new,
+    .getiter = mp_identity_getiter,
+    .iternext = mp_stream_unbuffered_iter,
+    .protocol = &vfs_tos_fileio_stream_p,
+    .locals_dict = (mp_obj_dict_t *)&vfs_tos_rawfile_locals_dict,
+};
+#endif /* MICROPY_PY_IO_FILEIO */
+
+STATIC const mp_stream_p_t vfs_tos_textio_stream_p = {
+    .read = vfs_tos_file_read,
+    .write = vfs_tos_file_write,
+    .ioctl = vfs_tos_file_ioctl,
+    .is_text = true,
+};
+
+const mp_obj_type_t mp_type_vfs_tos_textio = {
+    {&mp_type_type},
+    .name = MP_QSTR_TextIOWrapper,
+    .print = vfs_tos_file_print,
+    .make_new = vfs_tos_file_make_new,
+    .getiter = mp_identity_getiter,
+    .iternext = mp_stream_unbuffered_iter,
+    .protocol = &vfs_tos_textio_stream_p,
+    .locals_dict = (mp_obj_dict_t *)&vfs_tos_rawfile_locals_dict,
+};
+
+// Note: buffering and encoding args are currently ignored
+mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_file, ARG_mode, ARG_encoding };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_mode, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR_r)} },
+        { MP_QSTR_buffering, MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_encoding, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+    };
+
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // If the file is an integer then delegate straight to the POSIX handler
+    return mp_vfs_tos_file_open(&mp_type_textio, args[ARG_file].u_obj, args[ARG_mode].u_obj);
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
+
+#endif /* MICROPY_VFS_TOS */

components/language/micropython/port/mpconfigport.h

@@ -0,0 +1,252 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "mpconfigboard.h"
+
+#ifndef MICROPY_CONFIG_ROM_LEVEL
+#define MICROPY_CONFIG_ROM_LEVEL (MICROPY_CONFIG_ROM_LEVEL_EXTRA_FEATURES)
+#endif
+
+// Object representation
+#define MICROPY_OBJ_REPR (MICROPY_OBJ_REPR_A)
+
+// Optimisations
+#define MICROPY_OPT_COMPUTED_GOTO       (1)
+
+// Compiler configuration
+#define MICROPY_ENABLE_COMPILER         (1)
+#define MICROPY_KBD_EXCEPTION           (1)
+#define MICROPY_COMP_MODULE_CONST       (0)
+#define MICROPY_DEBUG_VERBOSE           (0)
+
+// Python internal features
+#define MICROPY_READER_POSIX            (0)
+#define MICROPY_ENABLE_GC               (1)
+#define MICROPY_HELPER_REPL             (1)
+#define MICROPY_PY_BUILTINS_HELP        (1)
+#define MICROPY_PY_BUILTINS_HELP_MODULES    (1)
+// #define MICROPY_TRACKED_ALLOC           (MICROPY_SSL_MBEDTLS)
+// #define MICROPY_ENABLE_PYSTACK          (0)
+#define MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF (1)
+#define MICROPY_REPL_INFO               (0)
+#define MICROPY_LONGINT_IMPL            (MICROPY_LONGINT_IMPL_MPZ)
+#define MICROPY_WARNINGS                (1)
+#define MICROPY_FLOAT_IMPL              (MICROPY_FLOAT_IMPL_FLOAT)
+// #define MICROPY_STREAMS_POSIX_API       (1)
+#define MICROPY_MODULE_FROZEN_STR       (0)
+#define MICROPY_MODULE_FROZEN_MPY       (0)
+#define MICROPY_USE_INTERNAL_ERRNO      (1)
+#define MICROPY_USE_INTERNAL_PRINTF     (0)
+#define MICROPY_SCHEDULER_DEPTH         (8)
+#define MICROPY_PY_SYS_STDIO_BUFFER     (1)
+#define MICROPY_ENABLE_SCHEDULER        (1)
+#ifdef MP_USING_VFS
+#define MICROPY_PY_IO                   (1)
+#define MICROPY_PY_UOS                  (1)
+#define MICROPY_READER_VFS              (1)
+#define MICROPY_VFS                     (1)
+#define MICROPY_VFS_TOS                 (1)
+#define MICROPY_VFS_POSIX               (0)
+#define MICROPY_VFS_FAT                 (0)
+#else
+#define MICROPY_PY_IO                   (0)
+#define MICROPY_READER_VFS              (0)
+#endif
+
+
+// Control over Python builtins
+#define MICROPY_PY_STR_BYTES_CMP_WARN   (1)
+#define MICROPY_PY_BUILTINS_RANGE_BINOP (0)
+#define MICROPY_PY_BUILTINS_NEXT2       (0)
+#define MICROPY_PY_ALL_INPLACE_SPECIAL_METHODS (1)
+#define MICROPY_PY_BUILTINS_HELP_TEXT   tencentos_tiny_help_text
+#define MICROPY_PY_GC_COLLECT_RETVAL    (0)
+// TODO: lgammaf() is not supported
+#define MICROPY_PY_MATH_SPECIAL_FUNCTIONS (0)
+#define MICROPY_PY_UTIME                (1)
+#define MICROPY_PY_UTIME_MP_HAL         (1)
+#define MICROPY_PY_THREAD               (1)
+
+// Extended modules
+// #define MICROPY_PY_UHASHLIB_MD5         (0)
+// #define MICROPY_PY_UHASHLIB_SHA1        (0)
+// #define MICROPY_PY_UHASHLIB_SHA256      (1)
+// #define MICROPY_PY_UCRYPTOLIB           (0)
+#define MICROPY_PY_OS_DUPTERM           (0)
+#define MICROPY_PY_UOS_DUPTERM_NOTIFY   (0)
+#define MICROPY_PY_UOS_UNAME            (1)
+#define MICROPY_PY_MACHINE              (1)
+#define MICROPY_PY_MACHINE_PIN_MAKE_NEW mp_pin_make_new
+#ifdef MP_USING_MACHINE_SPI
+#define MICROPY_PY_MACHINE_SPI          (1)
+#define MICROPY_PY_MACHINE_SOFTSPI      (1)
+#endif
+#ifdef MP_USING_MACHINE_I2C
+#define MICROPY_PY_MACHINE_I2C          (1)
+#define MICROPY_PY_MACHINE_SOFTI2C      (1)
+#endif
+
+#ifdef MP_USING_CMATH
+#define MICROPY_PY_CMATH                (1)
+#endif
+#ifdef MP_USING_UASYNCIO
+#define MICROPY_PY_UASYNCIO             (1)
+#endif
+#ifdef MP_USING_UCTYPES
+#define MICROPY_PY_UCTYPES              (1)
+#endif
+#ifdef MP_USING_UZLIBS
+#define MICROPY_PY_UZLIBS               (1)
+#endif
+#ifdef MP_USING_UJSON
+#define MICROPY_PY_UJSON                (1)
+#endif
+#ifdef MP_USING_URE
+#define MICROPY_PY_URE                  (1)
+#endif
+#ifdef MP_USING_HEAPQ
+#define MICROPY_PY_HEAPQ                (1)
+#endif
+#ifdef MP_USING_UHASHLIB
+#define MICROPY_PY_UHASHLIB             (1)
+#endif
+#ifdef MP_USING_UBINASCII
+#define MICROPY_PY_UBINASCII            (1)
+#endif
+#ifdef MP_USING_URANDOM
+#define MICROPY_PY_URANDOM              (1)
+#define MICROPY_PY_URANDOM_EXTRA_FUNCS  (1)
+#endif
+#ifdef MP_USING_FRAMEBUF
+#define MICROPY_PY_FRAMEBUF             (1)
+#endif
+
+
+#ifdef MP_USING_NETWORK
+#define MICROPY_PY_NETWORK              (1)
+#define MICROPY_PY_NETWORK_ESP8266      (1)
+#define MICROPY_PY_USOCKET              (1)
+#endif
+#ifdef MP_USING_USELECT
+#define MICROPY_PY_USELECT              (1)
+#endif
+
+
+#if MICROPY_VFS_TOS
+#define mp_type_fileio mp_type_vfs_tos_fileio
+#define mp_type_textio mp_type_vfs_tos_textio
+#elif MICROPY_VFS_FAT
+#define mp_type_fileio mp_type_vfs_fat_fileio
+#define mp_type_textio mp_type_vfs_fat_textio
+#elif MICROPY_VFS_POSIX
+#define mp_type_fileio mp_type_vfs_posix_fileio
+#define mp_type_textio mp_type_vfs_posix_textio
+#endif
+
+
+#if MICROPY_PY_NETWORK_ESP8266
+extern const struct _mod_network_nic_type_t mod_network_nic_type_esp8266;
+#define MICROPY_HW_NIC_ESP8266 \
+    { MP_ROM_QSTR(MP_QSTR_ESP8266), MP_ROM_PTR(&mod_network_nic_type_esp8266) },
+#else
+#define MICROPY_HW_NIC_ESP8266
+#endif
+
+#ifndef MICROPY_BOARD_NETWORK_INTERFACES
+#define MICROPY_BOARD_NETWORK_INTERFACES
+#endif
+
+#define MICROPY_PORT_NETWORK_INTERFACES \
+    MICROPY_HW_NIC_ESP8266 \
+    MICROPY_BOARD_NETWORK_INTERFACES \
+
+
+#define __BYTE_ORDER__  __ORDER_LITTLE_ENDIAN__
+
+#define MP_SSIZE_MAX (0x7fffffff)
+// Type definitions for the specific machine.
+typedef int mp_int_t; // must be pointer size
+typedef unsigned int mp_uint_t; // must be pointer size
+typedef long mp_off_t;
+#define UINT_FMT "%u"
+#define INT_FMT "%d"
+
+#define MICROPY_BEGIN_ATOMIC_SECTION()      tos_cpu_cpsr_save()
+#define MICROPY_END_ATOMIC_SECTION(state)   tos_cpu_cpsr_restore(state)
+
+#if MICROPY_PY_THREAD
+#define MICROPY_EVENT_POLL_HOOK \
+    do { \
+        extern void mp_handle_pending(bool); \
+        mp_handle_pending(true); \
+        MP_THREAD_GIL_EXIT(); \
+        tos_task_delay(1); \
+        MP_THREAD_GIL_ENTER(); \
+    } while (0);
+#else
+#define MICROPY_EVENT_POLL_HOOK \
+    do { \
+        extern void mp_handle_pending(bool); \
+        mp_handle_pending(true); \
+        /* tos_task_delay(1); */ \
+    } while (0);
+#endif
+
+#if defined(__CC_ARM)
+// #define MICROPY_GCREGS_SETJMP (1)
+#undef __GNUC__
+#undef __arm__
+#undef __thumb__
+#undef __thumb2__
+#endif
+
+#include <alloca.h>
+
+#define MICROPY_PY_SYS_PLATFORM                     "TencentOS-tiny"
+
+#define MP_STATE_PORT MP_STATE_VM
+
+#define MICROPY_PORT_ROOT_POINTERS \
+    const char *readline_hist[8]; \
+    struct _machine_uart_obj_t *stdio_uart; \
+    struct _machine_timer_obj_t *machine_timer_obj_head; \
+    mp_obj_list_t mod_network_nic_list; \
+
+
+
+
+
+
+
+
+
+
+
+
+

components/language/micropython/port/mphalport.c

@@ -0,0 +1,82 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+#include "py/mpthread.h"
+#include "py/mphal.h"
+#include "tos_k.h"
+#include "tos_hal.h"
+#include "machine_uart.h"
+// #include "mpshellport.h"
+
+int mp_hal_stdin_rx_chr(void) 
+{
+    while (1) {
+        // int c = mp_shell_getchar();
+        int c = -1;
+        struct _machine_uart_obj_t *uart = MP_STATE_PORT(stdio_uart);
+        if (uart != NULL) {
+            c = machine_uart_rx_chr(uart);
+        }
+        if (c != -1) {
+            return c;
+        }
+        MICROPY_EVENT_POLL_HOOK
+    }
+}
+
+void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) 
+{
+    struct _machine_uart_obj_t *uart = MP_STATE_PORT(stdio_uart);
+    machine_uart_tx_strn(uart, str, len);
+    // mp_shell_putsn(str, len);
+}
+
+void mp_hal_delay_ms(mp_uint_t ms)
+{
+    k_tick_t start_tick = tos_systick_get();
+    k_tick_t ticks = tos_millisec2tick(ms);
+    while (tos_systick_get() < start_tick + ticks) {
+        MICROPY_EVENT_POLL_HOOK
+        tos_task_delay(1);
+    }
+}
+
+mp_uint_t mp_hal_ticks_ms(void)
+{
+    return tos_tick2millisec(tos_systick_get());
+}
+
+mp_uint_t mp_hal_ticks_cpu(void)
+{
+    return tos_systick_get();
+}
+
+uint64_t mp_hal_time_ns(void)
+{
+    // not support
+    return 0;
+}

components/language/micropython/port/mphalport.h

@@ -0,0 +1,60 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define mp_hal_stdio_poll(poll_flags) (0) // NOT IMPLEMENT
+
+#include "mphalboard.h"
+#include "py/obj.h"
+#include "shared/runtime/interrupt_char.h"
+
+#if !(MP_GEN_HDR)
+#include "tos_k.h"
+#include "mp_tos_hal_pin.h"
+#endif
+
+#define MP_HAL_IS_PIN_MODE(mode) \
+   (((mode) == HAL_PIN_MODE_OUTPUT) || \
+    ((mode) == HAL_PIN_MODE_OUTPUT_OD) || \
+    ((mode) == HAL_PIN_MODE_INPUT) || \
+    ((mode) == HAL_PIN_MODE_INPUT_PULLUP) || \
+    ((mode) == HAL_PIN_MODE_INPUT_PULLDOWN))
+
+struct _machine_pin_obj_t;
+#define MP_HAL_PIN_FMT "%q"
+#define mp_hal_pin_obj_t struct _machine_pin_obj_t *
+void mp_hal_pin_write(mp_hal_pin_obj_t pin, int v);
+int mp_hal_pin_read(mp_hal_pin_obj_t pin);
+void mp_hal_pin_config(mp_hal_pin_obj_t pin, uint32_t mode);
+
+#define mp_hal_pin_high(pin)        mp_hal_pin_write((pin), 1)
+#define mp_hal_pin_low(pin)         mp_hal_pin_write((pin), 0)
+#define mp_hal_pin_od_high(pin)     mp_hal_pin_high(pin)
+#define mp_hal_pin_od_low(pin)      mp_hal_pin_low(pin)
+#define mp_hal_pin_input(pin)       mp_hal_pin_config((pin), HAL_PIN_MODE_INPUT)
+#define mp_hal_pin_output(pin)      mp_hal_pin_config((pin), HAL_PIN_MODE_OUTPUT)
+#define mp_hal_pin_open_drain(pin)  mp_hal_pin_config((pin), HAL_PIN_MODE_OUTPUT_OD)
+
+#define mp_hal_delay_us_fast(us)    mp_hal_delay_us(us)

components/language/micropython/port/mpmain.c

@@ -0,0 +1,231 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+#include "py/mphal.h"
+#include "py/mpthread.h"
+#include "py/compile.h"
+#include "py/gc.h"
+#include "py/mperrno.h"
+#include "py/stackctrl.h"
+#include "py/builtin.h"
+#include "shared/runtime/gchelper.h"
+#include "shared/runtime/pyexec.h"
+
+#include "modmachine.h"
+#if MICROPY_PY_NETWORK
+#include "extmod/modnetwork.h"
+#endif
+
+#if MICROPY_VFS_TOS
+#include "extmod/vfs.h"
+#include "vfs_tos.h"
+#endif
+
+#include "tos_k.h"
+
+#define MP_HEAP_SIZE        (8 * 1024)
+
+// MicroPython GC heap
+STATIC char *heap = NULL;
+STATIC void *stack_top = NULL;
+STATIC mp_obj_t uart_repl_obj;
+
+int mp_main(void) 
+{
+    // Initialise the MicroPython runtime
+    // mp_stack_ctrl_init();
+    volatile int stack_dummy;
+    #if MICROPY_PY_THREAD
+    mp_thread_init();
+    #endif
+    stack_top = (void *)&stack_dummy;
+
+    #ifdef MICROPY_HW_UART_REPL
+    {
+        mp_obj_t args[7] = {
+            MP_OBJ_NEW_SMALL_INT(MICROPY_HW_UART_REPL),
+            MP_OBJ_NEW_QSTR(MP_QSTR_rxbuf), MP_OBJ_NEW_SMALL_INT(512),
+            MP_OBJ_NEW_QSTR(MP_QSTR_timeout), MP_OBJ_NEW_SMALL_INT(0),
+            MP_OBJ_NEW_QSTR(MP_QSTR_timeout_char), MP_OBJ_NEW_SMALL_INT(2),
+        };
+        uart_repl_obj = machine_uart_type.make_new(&machine_uart_type, 1, 3, args);
+        machine_uart_attach_to_repl(MP_OBJ_TO_PTR(uart_repl_obj), 1);
+    }
+    #endif /* MICROPY_HW_UART_REPL */
+
+soft_reset:
+    mp_stack_set_top(stack_top);
+    mp_stack_set_limit(tos_task_curr_task_get()->stk_size - MP_THREAD_STACK_LIMIT_MARGIN);
+
+    if (!heap) {
+        heap = (char *)tos_mmheap_alloc(MP_HEAP_SIZE);
+        if (!heap) {
+            return -1;
+        }
+    }
+    gc_init(heap, heap + MP_HEAP_SIZE);
+    
+    mp_init();
+
+    #ifdef MICROPY_HW_UART_REPL
+    MP_STATE_PORT(stdio_uart) = MP_OBJ_TO_PTR(uart_repl_obj);
+    #endif /* MICROPY_HW_UART_REPL */
+
+    #if MICROPY_VFS_TOS
+    {
+        mp_obj_t root = mp_obj_new_str("/fs", 3);
+        mp_obj_t args[2] = {
+            mp_type_vfs_tos.make_new(&mp_type_vfs_tos, 1, 0, &root),
+            MP_OBJ_NEW_QSTR(MP_QSTR__slash_),
+        };
+        mp_vfs_mount(2, args, (mp_map_t *)&mp_const_empty_map);
+        MP_STATE_VM(vfs_cur) = MP_STATE_VM(vfs_mount_table);
+    }
+    #endif
+
+    #if MICROPY_PY_MACHINE
+    machine_pins_init();
+    #endif /* MICROPY_PY_MACHINE */
+
+    #if MICROPY_PY_NETWORK
+    mod_network_init();
+    #endif
+
+    // run boot-up scripts
+    // pyexec_frozen_module("_boot.py");
+    pyexec_file_if_exists("boot.py");
+    if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
+        int ret = pyexec_file_if_exists("main.py");
+        if (ret & PYEXEC_FORCED_EXIT) {
+            goto soft_reset_exit;
+        }
+    }
+
+    // start a normal REPL; will exit when ctrl-D is entered on a blank line.
+    for (;;) {
+        if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
+            if (pyexec_raw_repl() != 0) {
+                break;
+            }
+        } else {
+            if (pyexec_friendly_repl() != 0) {
+                break;
+            }
+        }
+    }
+
+soft_reset_exit:
+
+    #if MICROPY_PY_MACHINE
+    machine_timer_deinit_all();
+    #endif
+
+    #if MICROPY_PY_THREAD
+    mp_thread_deinit();
+    #endif
+    
+    // Deinitialise the runtime.
+    gc_sweep_all();
+
+    mp_hal_stdout_tx_str("MPY: soft reboot\r\n");
+
+    mp_deinit();
+
+    goto soft_reset;
+}
+
+// Handle uncaught exceptions (should never be reached in a correct C implemetation).
+void nlr_jump_fail(void *val) {
+    printf("FATAL: uncaught exception %p\n", val);
+    mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(val));
+    for (;;) {
+    }
+}
+
+// Do a garbage collection cycle
+void gc_collect(void) {
+
+    gc_collect_start();
+
+    uintptr_t stack_base = (uint32_t)tos_task_curr_task_get()->stk_base;
+    gc_collect_root((void **)stack_base, ((uintptr_t)MP_STATE_THREAD(stack_top) - (uintptr_t)stack_base) / sizeof(uintptr_t));
+    
+    #if MICROPY_PY_THREAD
+    // trace root pointers from any threads
+    mp_thread_gc_others();
+    #endif
+
+    gc_collect_end();
+    // gc_dump_info();
+}
+
+#if !(MICROPY_VFS)
+// There is no filesystem so stating returns noting
+mp_import_stat_t mp_import_stat(const char *path) {
+    return MP_IMPORT_STAT_NO_EXIST;
+}
+#endif /* MICROPY_VFS */
+
+#if !(MICROPY_READER_VFS)
+mp_lexer_t *mp_lexer_new_from_file(const char *filename) {
+    mp_raise_OSError(MP_ENOENT);
+}
+#endif
+
+#ifndef NDEBUG
+#if defined(__CC_ARM)
+void __aeabi_assert(const char *expr, const char *file, int line) {
+    printf("Assertion '%s' failed, at file %s:%d\n", expr, file, line);
+    for (;;) {
+    }
+}
+#endif
+NORETURN void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) {
+    (void)func;
+    printf("Assertion '%s' failed, at file %s:%d\n", expr, file, line);
+    mp_raise_msg(&mp_type_AssertionError, MP_ERROR_TEXT("C-level assert"));
+}
+#endif
+
+#if MICROPY_DEBUG_VERBOSE
+#include <stdio.h>
+#include <stdarg.h>
+int DEBUG_printf(const char *format, ...)
+{
+    static char log_buf[512];
+    va_list args;
+
+    /* args point to the first variable parameter */
+    va_start(args, format);
+    /* must use vprintf to print */
+    vsprintf(log_buf, format, args);
+    printf("%s", log_buf);
+    va_end(args);
+
+    return 0;
+}
+#endif

components/language/micropython/port/mpmain.h

@@ -0,0 +1,32 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef _MPMAIN_H_
+#define _MPMAIN_H_
+
+int mp_main(void);
+
+#endif /* _MPMAIN_H_ */

components/language/micropython/port/mpthreadport.c

@@ -0,0 +1,224 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+#include "py/mpthread.h"
+#include "py/gc.h"
+#include "py/runtime.h"
+#include "tos_k.h"
+
+#if MICROPY_PY_THREAD
+
+#define MP_THREAD_MIN_STACK_SIZE                        (2 * 1024)
+#define MP_THREAD_DEFAULT_STACK_SIZE                    (4 * 1024)
+
+// this structure form a linked list, one node per active thread
+typedef struct _mp_thread_t {
+    k_task_t *id;
+    int ready;
+    void *arg;
+    void *stack;
+    size_t stack_len;
+    struct _mp_thread_t *next;
+    void *data;
+} mp_thread_t;
+
+// the mutex controls access to the linked list
+STATIC mp_thread_mutex_t thread_mutex;
+STATIC mp_thread_t thread_entry0;
+STATIC mp_thread_t *thread = NULL;
+
+void mp_thread_init(void)
+{
+    mp_thread_mutex_init(&thread_mutex);
+
+    // create first entry in linked list of all threads
+    thread = &thread_entry0;
+    thread->id = tos_task_curr_task_get();
+    thread->ready = 1;
+    thread->arg = NULL;
+    thread->stack = thread->id->stk_base;
+    thread->stack_len = thread->id->stk_size / sizeof(uintptr_t);
+    thread->next = NULL;
+    // mp_thread_set_state(&mp_state_ctx.thread)
+    thread->data = &mp_state_ctx.thread;
+}
+
+void mp_thread_gc_others(void)
+{
+    mp_thread_mutex_lock(&thread_mutex, 1);
+    for (mp_thread_t *th = thread; th != NULL; th = th->next) {
+        gc_collect_root((void **)&th, 1);
+        gc_collect_root(&th->arg, 1);
+        gc_collect_root(&th->stack, 1);
+        if (th->id != tos_task_curr_task_get() && th->ready) {
+            gc_collect_root(th->stack, th->stack_len);
+        }
+    }
+    mp_thread_mutex_unlock(&thread_mutex);
+}
+
+void mp_thread_deinit(void)
+{
+    for (;;) {
+        k_task_t *id = NULL;
+        mp_thread_mutex_lock(&thread_mutex, 1);
+        for (mp_thread_t *th = thread; th != NULL; th = th->next) {
+            if (th->id != tos_task_curr_task_get()) {
+                id = th->id;
+                break;
+            }
+        }
+        mp_thread_mutex_unlock(&thread_mutex);
+        if (id == NULL) {
+            break;
+        } else {
+            tos_task_destroy(id);
+        }
+    }
+}
+
+void mp_thread_set_state(mp_state_thread_t *state)
+{
+    mp_thread_mutex_lock(&thread_mutex, 1);
+    k_task_t *id = tos_task_curr_task_get();
+    for (mp_thread_t *th = thread; th != NULL; th = th->next) {
+        if (th->id == id) {
+            th->data = (void *)state;
+            break;
+        }
+    }
+    mp_thread_mutex_unlock(&thread_mutex);
+}
+
+mp_state_thread_t *mp_thread_get_state(void)
+{
+    mp_thread_mutex_lock(&thread_mutex, 1);
+    k_task_t *id = tos_task_curr_task_get();
+    for (mp_thread_t *th = thread; th != NULL; th = th->next) {
+        if (th->id == id) {
+            mp_thread_mutex_unlock(&thread_mutex);
+            return (mp_state_thread_t *)th->data;
+        }
+    }
+    mp_thread_mutex_unlock(&thread_mutex);
+    return NULL;
+}
+
+
+void mp_thread_create_ex(void *(*entry)(void *), void *arg, size_t *stack_size, int priority, char *name) {
+    
+    if (*stack_size == 0) {
+        *stack_size = MP_THREAD_DEFAULT_STACK_SIZE;
+    } else if (*stack_size < MP_THREAD_MIN_STACK_SIZE) {
+        *stack_size = MP_THREAD_MIN_STACK_SIZE;
+    }
+
+    // Allocate linked-list node (must be outside thread_mutex lock)
+    mp_thread_t *th = m_new_obj(mp_thread_t);
+
+    mp_thread_mutex_lock(&thread_mutex, 1);
+
+    // create thread
+    k_err_t ret = tos_task_create_dyn(&th->id, name, (k_task_entry_t)entry, arg, priority, *stack_size, 0);
+    if (ret != K_ERR_NONE) {
+        mp_thread_mutex_unlock(&thread_mutex);
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't create thread"));
+    }
+
+    // add thread to linked list of all threads
+    th->ready = 0;
+    th->arg = arg;
+    th->stack = th->id->stk_base;
+    th->stack_len = *stack_size / sizeof(uintptr_t);
+    th->next = thread;
+    thread = th;
+
+    // adjust the stack_size to provide room to recover from hitting the limit
+    *stack_size -= MP_THREAD_STACK_LIMIT_MARGIN;
+
+    mp_thread_mutex_unlock(&thread_mutex);
+}
+
+void mp_thread_create(void *(*entry)(void *), void *arg, size_t *stack_size)
+{
+    int priority = tos_task_curr_task_get()->prio;
+    if (priority > 0) {
+        // subthread has higher priority
+        priority -= 1;
+    }
+    mp_thread_create_ex(entry, arg, stack_size, priority, "mp_thread");
+}
+
+void mp_thread_start(void)
+{
+    mp_thread_mutex_lock(&thread_mutex, 1);
+    for (mp_thread_t *th = thread; th != NULL; th = th->next) {
+        if (th->id == tos_task_curr_task_get()) {
+            th->ready = 1;
+            break;
+        }
+    }
+    mp_thread_mutex_unlock(&thread_mutex);
+}
+
+void mp_thread_finish(void)
+{
+    mp_thread_mutex_lock(&thread_mutex, 1);
+    for (mp_thread_t *th = thread, *prev = NULL; th != NULL; prev = th, th = th->next) {
+        if (th->id == tos_task_curr_task_get()) {
+            if (prev != NULL) {
+                prev->next = th->next;
+            } else {
+                thread = th->next;
+            }
+            th->ready = 0;
+            m_del_obj(mp_thread_t, th);
+            break;
+        }
+    }
+    mp_thread_mutex_unlock(&thread_mutex);
+    tos_task_destroy_dyn(NULL);
+}
+
+
+void mp_thread_mutex_init(mp_thread_mutex_t *mutex)
+{
+    // TODO return value
+    tos_mutex_create(mutex);
+}
+
+int mp_thread_mutex_lock(mp_thread_mutex_t *mutex, int wait)
+{
+    return K_ERR_NONE == tos_mutex_pend_timed(mutex, wait ? TOS_TIME_FOREVER : TOS_TIME_NOWAIT);
+}
+
+void mp_thread_mutex_unlock(mp_thread_mutex_t *mutex) 
+{
+    tos_mutex_post(mutex);
+}
+
+#endif /* MICROPY_PY_THREAD */

components/language/micropython/port/mpthreadport.h

@@ -0,0 +1,48 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 KY-zhang-X
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef _MPTHREADPORT_H_
+#define _MPTHREADPORT_H_
+
+#if !(MP_GEN_HDR)
+#include "tos_k.h"
+#else
+struct k_mutex_st;
+typedef struct k_mutex_st k_mutex_t;
+#endif
+
+#define MP_THREAD_STACK_LIMIT_MARGIN                    (1024)
+
+// typedef struct _mp_thread_mutex_t {
+//     k_mutex_t mutex;
+// } mp_thread_mutex_t;
+typedef k_mutex_t mp_thread_mutex_t;
+
+void mp_thread_init(void);
+void mp_thread_gc_others(void);
+void mp_thread_deinit(void);
+
+#endif /* _MPTHREAD_PORT_H_ */

components/language/micropython/port/unistd.h

@@ -0,0 +1,15 @@
+#ifndef MICROPY_INCLUDED_TENCENTOS_UNISTD_H
+#define MICROPY_INCLUDED_TENCENTOS_UNISTD_H
+
+// keil compiler doesn't seem to have unistd.h file
+
+#define SEEK_SET 0
+#define SEEK_CUR 1
+
+typedef int ssize_t;
+
+// #define STDIN_FILENO  0
+// #define STDOUT_FILENO 1
+// #define STDERR_FILENO 2
+
+#endif // MICROPY_INCLUDED_TENCENTOS_UNISTD_H