修复若干bug&完善fatfs服务&完善app

.vscode/settings.json

@@ -151,7 +151,30 @@
         "variant": "c",
         "soft_iic.h": "c",
         "sysinfo.h": "c",
-        "u_sleep.h": "c"
+        "u_sleep.h": "c",
+        "hmi_user_uart.h": "c",
+        "usart3.h": "c",
+        "u_local_thread.h": "c",
+        "string": "c",
+        "string_view": "c",
+        "vector": "c",
+        "cstddef": "c",
+        "usart2.h": "c",
+        "hmi_lcd_process.h": "c",
+        "stdlib.h": "c",
+        "auto_close.h": "c",
+        "u_sys.h": "c",
+        "relay.h": "c",
+        "spi1.h": "c",
+        "led.h": "c",
+        "adc.h": "c",
+        "w25q64.h": "c",
+        "__bit_reference": "c",
+        "unordered_map": "c",
+        "__strerror.h": "c",
+        "sstream": "c",
+        "u_drv.h": "c",
+        "__node_handle": "c"
     },
     "cortex-debug.showRTOS": false,
     "cortex-debug.variableUseNaturalFormat": false,

mkrtos_knl/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.13)
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} \
 -Werror \
--D__MPU_PRESENT=1 -DUSE_STDPERIPH_DRIVER=1 -DSTM32F10X_XL \
+-D__MPU_PRESENT=1 -DUSE_STDPERIPH_DRIVER=1 \
 -DKNL_OFFSET=$ENV{KEN_OFFSET} \
 -DKNL_TEXT=$ENV{KNL_TEXT} \
 -DINIT_OFFSET=$ENV{INIT_OFFSET} \
@@ -13,6 +13,13 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} \
 -Wno-unused-variable \
 ")
 set(CMAKE_ASM_FLAGS ${CMAKE_C_FLAGS})
+
+
+if (${BOARD_NAME} STREQUAL "STM32F1x")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSTM32F10X_XL ")
+elseif(${BOARD_NAME} STREQUAL "STM32F2x" )
+endif()
+
 message(编译参数：${CMAKE_C_FLAGS})
 add_subdirectory(arch)
 add_subdirectory(drivers)

mkrtos_knl/arch/armv7m/core_it.c

@@ -187,27 +187,27 @@ void UsageFault_Handler(void)
   printk("%s\n", __FUNCTION__);
   if (SCB->CFSR & (1 << 16))
   {
-    printk("未定义指令错误\n");
+    printk("Undefined instruction error\n");
   }
   if (SCB->CFSR & (1 << 17))
   {
-    printk("试图切换到错误的状态\n");
+    printk("Trying to switch to the wrong state\n");
   }
   if (SCB->CFSR & (1 << 18))
   {
-    printk("试图执行EXC_RETURN错误的异常\n");
+    printk("An exception attempting to execute an EXC_RETURN error\n");
   }
   if (SCB->CFSR & (1 << 19))
   {
-    printk("试图执行协处理器指令\n");
+    printk("An attempt was made to execute a coprocessor instruction\n");
   }
   if (SCB->CFSR & (1 << 24))
   {
-    printk("产生了非对其访问错误\n");
+    printk("A non-access error was generated\n");
   }
   if (SCB->CFSR & (1 << 25))
   {
-    printk("除零错误\n");
+    printk("Division by zero error\n");
   }
   /* Go to infinite loop when Usage Fault exception occurs */
   // while (1)

mkrtos_knl/inc/knl/irq_sender.h

@@ -25,5 +25,5 @@ typedef struct irq_sender
 } irq_sender_t;
 
 void irq_sender_init(irq_sender_t *irq);
-int irq_sender_wait(irq_sender_t *irq, thread_t *th);
+int irq_sender_wait(irq_sender_t *irq, thread_t *th, int flags);
 void irq_sender_syscall(kobject_t *kobj, syscall_prot_t sys_p, msg_tag_t in_tag, entry_frame_t *f);

mkrtos_knl/inc/lib/fcntl.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#define O_NONBLOCK 04000
+#define O_NDELAY O_NONBLOCK

mkrtos_knl/knl/irq_sender.c

@@ -18,6 +18,7 @@
 #include <factory.h>
 #include <irq.h>
 #include <task.h>
+#include <fcntl.h>
 /**
  * @brief irq sender的操作号
  *
@@ -54,7 +55,7 @@ static void irq_tigger(irq_entry_t *irq)
  * @param th
  * @return int
  */
-int irq_sender_wait(irq_sender_t *irq, thread_t *th)
+int irq_sender_wait(irq_sender_t *irq, thread_t *th, int flags)
 {
     umword_t status = cpulock_lock();
 
@@ -63,23 +64,35 @@ int irq_sender_wait(irq_sender_t *irq, thread_t *th)
         irq->wait_thread = th;
         if (irq->irq_cn > 0)
         {
-            irq->irq_cn = 0;
             cpulock_set(status);
+            irq->irq_cn = 0;
+            irq->wait_thread = NULL;
         }
         else
         {
-            thread_suspend(irq->wait_thread);
+            int ret = 0;
+
+            if (!(flags & O_NONBLOCK))
+            {
+                thread_suspend(irq->wait_thread);
+                ret = 0;
+            }
+            else
+            {
+                ret = -EAGAIN;
+            }
             cpulock_set(status);
+            irq->irq_cn = 0;
             irq->wait_thread = NULL;
+            return ret;
         }
-        irq->irq_cn = 0;
         return 0;
     }
     else
     {
         cpulock_set(status);
 
-        return -EACCES;
+        return -EAGAIN;
     }
 }
 static bool_t irq_sender_unbind(irq_sender_t *irq, int irq_no)
@@ -140,7 +153,7 @@ void irq_sender_syscall(kobject_t *kobj, syscall_prot_t sys_p, msg_tag_t in_tag,
     case WAIT_IRQ:
     {
         ref_counter_inc(&th->ref);
-        int ret = irq_sender_wait(irq, th);
+        int ret = irq_sender_wait(irq, th, f->r[1]);
         ref_counter_dec_and_release(&th->ref, &irq->kobj); //! 引用计数+1
         tag = msg_tag_init4(0, 0, 0, ret);
     }

mkrtos_knl/knl/log.c

@@ -68,7 +68,7 @@ static int log_read_data(log_t *log, uint8_t *data, int len)
 
         if (c < 0 && i == 0)
         {
-            int ret = irq_sender_wait(&log->kobj, thread_get_current());
+            int ret = irq_sender_wait(&log->kobj, thread_get_current(), 0);
             if (ret < 0)
             {
                 return ret;

mkrtos_knl/knl/map.c

@@ -1,12 +1,12 @@
 /**
  * @file map.c
  * @author zhangzheng (1358745329@qq.com)
- * @brief 
+ * @brief
  * @version 0.1
  * @date 2023-09-29
- * 
+ *
  * @copyright Copyright (c) 2023
- * 
+ *
  */
 #include "map.h"
 #include "types.h"
@@ -28,14 +28,14 @@ bool_t obj_map_root(kobject_t *kobj, obj_space_t *obj_space, ram_limit_t *ram, v
 }
 /**
  * @brief 从源映射到目的，如果目的中已经存在，则先解除目的映射然后在影视
- * 
+ *
- * @param dst_space 
+ * @param dst_space
- * @param src_space 
+ * @param src_space
- * @param dst_inx 
+ * @param dst_inx
- * @param src_inx 
+ * @param src_inx
- * @param ram 
+ * @param ram
- * @param del_attrs 
+ * @param del_attrs
- * @return int 
+ * @return int
  */
 int obj_map_src_dst(obj_space_t *dst_space, obj_space_t *src_space,
                     obj_handler_t dst_inx, obj_handler_t src_inx,
@@ -52,7 +52,8 @@ int obj_map_src_dst(obj_space_t *dst_space, obj_space_t *src_space,
         return -ENOENT;
     }
 
-    if (obj_space_lookup_kobj(dst_space, dst_inx)) { //!< 已经存在则解除注释
+    if (obj_space_lookup_kobj(dst_space, dst_inx))
+    { //!< 已经存在则解除注释
         obj_unmap(dst_space, vpage_create3(0, 0, dst_inx), del_list);
     }
 
@@ -101,10 +102,11 @@ void obj_unmap(obj_space_t *obj_space, vpage_t vpage, kobj_del_list_t *del_list)
     {
         //!< 代表删除所有
         obj_map_entry_t *pos;
+    again:
 
         slist_foreach(pos, &kobj->mappable.node, node)
         {
-            slist_del(&entry->node);
+            slist_del(&pos->node);
             entry->obj = NULL;
             // 删除一个
             kobj->mappable.map_cnt--;
@@ -115,6 +117,7 @@ void obj_unmap(obj_space_t *obj_space, vpage_t vpage, kobj_del_list_t *del_list)
                     kobj_del_list_add(del_list, &kobj->del_node);
                 }
             }
+            goto again;
         }
     }
     else

mkrtos_knl/knl/scheduler.c

@@ -18,7 +18,10 @@ umword_t sched_reset = 0;
 
 void scheduler_reset(void)
 {
+    scheduler_t *sched = scheduler_get_current();
+
     sched_reset = 0;
+    sched->cur_sche = NULL;
 }
 
 scheduler_t *scheduler_get_current(void)

mkrtos_knl/knl/task.c

@@ -38,7 +38,7 @@ int task_alloc_base_ram(task_t *tk, ram_limit_t *lim, size_t size)
     void *ram = mpu_ram_alloc(&tk->mm_space, lim, size + THREAD_MSG_BUG_LEN);
     if (!ram)
     {
-        printk("申请进程内存失败.\n");
+        printk("Failed to request process memory.\n");
         return -ENOMEM;
     }
     mm_space_set_ram_block(&tk->mm_space, ram, size + THREAD_MSG_BUG_LEN);
@@ -168,10 +168,9 @@ static void task_release_stage2(kobject_t *kobj)
     mm_limit_free_align(tk->lim, tk->mm_space.mm_block, tk->mm_space.mm_block_size);
     mm_limit_free(tk->lim, tk);
     // if (cur_tk == tk)
-    {
+    // {
-        thread_sched();
+    thread_sched();
-    }
+    // }
-    scheduler_reset();
     // mm_trace();
     printk("release tk %x\n", tk);
 }

mkrtos_knl/knl/thread.c

@@ -91,10 +91,11 @@ static void thread_release_stage2(kobject_t *kobj)
     printk("release thread 0x%x\n", kobj);
     mm_limit_free_align(th->lim, kobj, THREAD_BLOCK_SIZE);
 
-    // if (cur_th == th)
+    if (cur_th == th)
-    // {
+    {
-    thread_sched();
+        thread_sched();
-    // }
+        scheduler_reset();
+    }
 }
 
 /**

mkrtos_knl/knl/thread_knl.c

@@ -84,6 +84,7 @@ static void knl_init_2(void)
             assert(obj_map_root(kobj, &init_task->obj_space, &root_factory_get()->limit, vpage_create3(KOBJ_ALL_RIGHTS, 0, i)));
         }
     }
+    init_thread->sche.prio = 2;
     thread_ready(init_thread, FALSE);
 }
 INIT_STAGE2(knl_init_2);

mkrtos_user/lib/CMakeLists.txt

@@ -9,6 +9,7 @@ set(CMAKE_ASM_FLAGS ${CMAKE_C_FLAGS})
 add_subdirectory(sys)
 add_subdirectory(sys_util)
 add_subdirectory(sys_svr)
+add_subdirectory(stm32f1_bsp)
 add_subdirectory(libc_backend)
 add_subdirectory(mlibc)
 add_subdirectory(cpio)

mkrtos_user/lib/mlibc/include/stdlib.h

@@ -2,7 +2,8 @@
 #define _STDLIB_H
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 #include <features.h>
@@ -12,7 +13,9 @@ extern "C" {
 #elif defined(__cplusplus)
 #define NULL 0L
 #else
-#define NULL ((void*)0)
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
 #endif
 
 #define __NEED_size_t
@@ -20,147 +23,151 @@ extern "C" {
 
 #include <bits/alltypes.h>
 
-int atoi (const char *);
+    int atoi(const char *);
-long atol (const char *);
+    long atol(const char *);
-long long atoll (const char *);
+    long long atoll(const char *);
-double atof (const char *);
+    double atof(const char *);
 
-float strtof (const char *__restrict, char **__restrict);
+    float strtof(const char *__restrict, char **__restrict);
-double strtod (const char *__restrict, char **__restrict);
+    double strtod(const char *__restrict, char **__restrict);
-long double strtold (const char *__restrict, char **__restrict);
+    long double strtold(const char *__restrict, char **__restrict);
 
-long strtol (const char *__restrict, char **__restrict, int);
+    long strtol(const char *__restrict, char **__restrict, int);
-unsigned long strtoul (const char *__restrict, char **__restrict, int);
+    unsigned long strtoul(const char *__restrict, char **__restrict, int);
-long long strtoll (const char *__restrict, char **__restrict, int);
+    long long strtoll(const char *__restrict, char **__restrict, int);
-unsigned long long strtoull (const char *__restrict, char **__restrict, int);
+    unsigned long long strtoull(const char *__restrict, char **__restrict, int);
 
-int rand (void);
+    int rand(void);
-void srand (unsigned);
+    void srand(unsigned);
 
-void *malloc (size_t);
+    void *malloc(size_t);
-void *calloc (size_t, size_t);
+    void *calloc(size_t, size_t);
-void *realloc (void *, size_t);
+    void *realloc(void *, size_t);
-void free (void *);
+    void free(void *);
-void *aligned_alloc(size_t, size_t);
+    void *aligned_alloc(size_t, size_t);
 
-_Noreturn void abort (void);
+    _Noreturn void abort(void);
-int atexit (void (*) (void));
+    int atexit(void (*)(void));
-_Noreturn void exit (int);
+    _Noreturn void exit(int);
-_Noreturn void _Exit (int);
+    _Noreturn void _Exit(int);
-int at_quick_exit (void (*) (void));
+    int at_quick_exit(void (*)(void));
-_Noreturn void quick_exit (int);
+    _Noreturn void quick_exit(int);
 
-char *getenv (const char *);
+    char *getenv(const char *);
 
-int system (const char *);
+    int system(const char *);
 
-void *bsearch (const void *, const void *, size_t, size_t, int (*)(const void *, const void *));
+    void *bsearch(const void *, const void *, size_t, size_t, int (*)(const void *, const void *));
-void qsort (void *, size_t, size_t, int (*)(const void *, const void *));
+    void qsort(void *, size_t, size_t, int (*)(const void *, const void *));
 
-int abs (int);
+    int abs(int);
-long labs (long);
+    long labs(long);
-long long llabs (long long);
+    long long llabs(long long);
 
-typedef struct { int quot, rem; } div_t;
+    typedef struct
-typedef struct { long quot, rem; } ldiv_t;
+    {
-typedef struct { long long quot, rem; } lldiv_t;
+        int quot, rem;
+    } div_t;
+    typedef struct
+    {
+        long quot, rem;
+    } ldiv_t;
+    typedef struct
+    {
+        long long quot, rem;
+    } lldiv_t;
 
-div_t div (int, int);
+    div_t div(int, int);
-ldiv_t ldiv (long, long);
+    ldiv_t ldiv(long, long);
-lldiv_t lldiv (long long, long long);
+    lldiv_t lldiv(long long, long long);
 
-int mblen (const char *, size_t);
+    int mblen(const char *, size_t);
-int mbtowc (wchar_t *__restrict, const char *__restrict, size_t);
+    int mbtowc(wchar_t *__restrict, const char *__restrict, size_t);
-int wctomb (char *, wchar_t);
+    int wctomb(char *, wchar_t);
-size_t mbstowcs (wchar_t *__restrict, const char *__restrict, size_t);
+    size_t mbstowcs(wchar_t *__restrict, const char *__restrict, size_t);
-size_t wcstombs (char *__restrict, const wchar_t *__restrict, size_t);
+    size_t wcstombs(char *__restrict, const wchar_t *__restrict, size_t);
 
 #define EXIT_FAILURE 1
 #define EXIT_SUCCESS 0
 
-size_t __ctype_get_mb_cur_max(void);
+    size_t __ctype_get_mb_cur_max(void);
 #define MB_CUR_MAX (__ctype_get_mb_cur_max())
 
 #define RAND_MAX (0x7fffffff)
 
+#if defined(_POSIX_SOURCE) || defined(_POSIX_C_SOURCE) || defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
 
-#if defined(_POSIX_SOURCE) || defined(_POSIX_C_SOURCE) \
+#define WNOHANG 1
- || defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) \
+#define WUNTRACED 2
- || defined(_BSD_SOURCE)
 
-#define WNOHANG    1
+#define WEXITSTATUS(s) (((s)&0xff00) >> 8)
-#define WUNTRACED  2
+#define WTERMSIG(s) ((s)&0x7f)
-
-#define WEXITSTATUS(s) (((s) & 0xff00) >> 8)
-#define WTERMSIG(s) ((s) & 0x7f)
 #define WSTOPSIG(s) WEXITSTATUS(s)
 #define WIFEXITED(s) (!WTERMSIG(s))
-#define WIFSTOPPED(s) ((short)((((s)&0xffff)*0x10001U)>>8) > 0x7f00)
+#define WIFSTOPPED(s) ((short)((((s)&0xffff) * 0x10001U) >> 8) > 0x7f00)
-#define WIFSIGNALED(s) (((s)&0xffff)-1U < 0xffu)
+#define WIFSIGNALED(s) (((s)&0xffff) - 1U < 0xffu)
 
-int posix_memalign (void **, size_t, size_t);
+    int posix_memalign(void **, size_t, size_t);
-int setenv (const char *, const char *, int);
+    int setenv(const char *, const char *, int);
-int unsetenv (const char *);
+    int unsetenv(const char *);
-int mkstemp (char *);
+    int mkstemp(char *);
-int mkostemp (char *, int);
+    int mkostemp(char *, int);
-char *mkdtemp (char *);
+    char *mkdtemp(char *);
-int getsubopt (char **, char *const *, char **);
+    int getsubopt(char **, char *const *, char **);
-int rand_r (unsigned *);
+    int rand_r(unsigned *);
 
 #endif
 
-
+#if defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
-#if defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) \
+    char *realpath(const char *__restrict, char *__restrict);
- || defined(_BSD_SOURCE)
+    long int random(void);
-char *realpath (const char *__restrict, char *__restrict);
+    void srandom(unsigned int);
-long int random (void);
+    char *initstate(unsigned int, char *, size_t);
-void srandom (unsigned int);
+    char *setstate(char *);
-char *initstate (unsigned int, char *, size_t);
+    int putenv(char *);
-char *setstate (char *);
+    int posix_openpt(int);
-int putenv (char *);
+    int grantpt(int);
-int posix_openpt (int);
+    int unlockpt(int);
-int grantpt (int);
+    char *ptsname(int);
-int unlockpt (int);
+    char *l64a(long);
-char *ptsname (int);
+    long a64l(const char *);
-char *l64a (long);
+    void setkey(const char *);
-long a64l (const char *);
+    double drand48(void);
-void setkey (const char *);
+    double erand48(unsigned short[3]);
-double drand48 (void);
+    long int lrand48(void);
-double erand48 (unsigned short [3]);
+    long int nrand48(unsigned short[3]);
-long int lrand48 (void);
+    long mrand48(void);
-long int nrand48 (unsigned short [3]);
+    long jrand48(unsigned short[3]);
-long mrand48 (void);
+    void srand48(long);
-long jrand48 (unsigned short [3]);
+    unsigned short *seed48(unsigned short[3]);
-void srand48 (long);
+    void lcong48(unsigned short[7]);
-unsigned short *seed48 (unsigned short [3]);
-void lcong48 (unsigned short [7]);
 #endif
 
 #if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
 #include <alloca.h>
-char *mktemp (char *);
+    char *mktemp(char *);
-int mkstemps (char *, int);
+    int mkstemps(char *, int);
-int mkostemps (char *, int, int);
+    int mkostemps(char *, int, int);
-void *valloc (size_t);
+    void *valloc(size_t);
-void *memalign(size_t, size_t);
+    void *memalign(size_t, size_t);
-int getloadavg(double *, int);
+    int getloadavg(double *, int);
-int clearenv(void);
+    int clearenv(void);
-#define WCOREDUMP(s) ((s) & 0x80)
+#define WCOREDUMP(s) ((s)&0x80)
 #define WIFCONTINUED(s) ((s) == 0xffff)
-void *reallocarray (void *, size_t, size_t);
+    void *reallocarray(void *, size_t, size_t);
-void qsort_r (void *, size_t, size_t, int (*)(const void *, const void *, void *), void *);
+    void qsort_r(void *, size_t, size_t, int (*)(const void *, const void *, void *), void *);
 #endif
 
 #ifdef _GNU_SOURCE
-int ptsname_r(int, char *, size_t);
+    int ptsname_r(int, char *, size_t);
-char *ecvt(double, int, int *, int *);
+    char *ecvt(double, int, int *, int *);
-char *fcvt(double, int, int *, int *);
+    char *fcvt(double, int, int *, int *);
-char *gcvt(double, int, char *);
+    char *gcvt(double, int, char *);
-char *secure_getenv(const char *);
+    char *secure_getenv(const char *);
-struct __locale_struct;
+    struct __locale_struct;
-float strtof_l(const char *__restrict, char **__restrict, struct __locale_struct *);
+    float strtof_l(const char *__restrict, char **__restrict, struct __locale_struct *);
-double strtod_l(const char *__restrict, char **__restrict, struct __locale_struct *);
+    double strtod_l(const char *__restrict, char **__restrict, struct __locale_struct *);
-long double strtold_l(const char *__restrict, char **__restrict, struct __locale_struct *);
+    long double strtold_l(const char *__restrict, char **__restrict, struct __locale_struct *);
 #endif
 
 #if defined(_LARGEFILE64_SOURCE)

mkrtos_user/lib/mlibc/obj/include/bits/syscall.h

@@ -79,7 +79,7 @@
 #define __NR_stat	106
 #define __NR_lstat	107
 #define __NR_fstat	108
-#define __NR_vhangup	111
+#define __NR_vhangup	447//111
 #define __NR_wait4	114
 #define __NR_swapoff	115
 #define __NR_sysinfo	116
@@ -404,7 +404,7 @@
 #define __ARM_NR_cacheflush	0x0f0002
 #define __ARM_NR_usr26		0x0f0003
 #define __ARM_NR_usr32		0x0f0004
-#define __ARM_NR_set_tls	0x447//0x0f0005
+#define __ARM_NR_set_tls	111//0x0f0005
 #define __ARM_NR_get_tls	0x0f0006
 
 #define SYS_restart_syscall	0

mkrtos_user/lib/mlibc/src/errno/strerror.c

@@ -5,13 +5,15 @@
 
 /* mips has one error code outside of the 8-bit range due to a
  * historical typo, so we just remap it. */
-#if EDQUOT==1133
+#if EDQUOT == 1133
 #define EDQUOT_ORIG 1133
-#undef  EDQUOT
+#undef EDQUOT
 #define EDQUOT 109
 #endif
 
-static const struct errmsgstr_t {
+static const struct errmsgstr_t
+{
+#ifdef NO_LITTLE_MODE
 #define E(n, s) char str##n[sizeof(s)];
 #include "__strerror.h"
 #undef E
@@ -19,24 +21,34 @@ static const struct errmsgstr_t {
 #define E(n, s) s,
 #include "__strerror.h"
 #undef E
+#endif
 };
 
 static const unsigned short errmsgidx[] = {
+#ifdef NO_LITTLE_MODE
 #define E(n, s) [n] = offsetof(struct errmsgstr_t, str##n),
 #include "__strerror.h"
 #undef E
+#endif
 };
 
 char *__strerror_l(int e, locale_t loc)
 {
+#ifdef NO_LITTLE_MODE
 	const char *s;
 #ifdef EDQUOT_ORIG
-	if (e==EDQUOT) e=0;
+	if (e == EDQUOT)
-	else if (e==EDQUOT_ORIG) e=EDQUOT;
+		e = 0;
+	else if (e == EDQUOT_ORIG)
+		e = EDQUOT;
 #endif
-	if (e >= sizeof errmsgidx / sizeof *errmsgidx) e = 0;
+	if (e >= sizeof errmsgidx / sizeof *errmsgidx)
+		e = 0;
 	s = (char *)&errmsgstr + errmsgidx[e];
 	return (char *)LCTRANS(s, LC_MESSAGES, loc);
+#else
+	return "error.";
+#endif
 }
 
 char *strerror(int e)

mkrtos_user/lib/stm32f1_bsp/CMakeLists.txt

@@ -0,0 +1,43 @@
+cmake_minimum_required(VERSION 3.13)
+
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_STDPERIPH_DRIVER=1 -DSTM32F10X_XL \
+-fPIC -n -pie -fpie -fpic -msingle-pic-base -mno-pic-data-is-text-relative \
+-Wl,--gc-sections -D__dietlibc__ -D__arm__ -D__WORDSIZE=32 -D__ARM_ARCH_7M__ \
+" )
+set(CMAKE_ASM_FLAGS ${CMAKE_C_FLAGS})
+
+
+file(GLOB_RECURSE deps  *.c *.S)
+add_library(
+    stm32f1_bsp
+    STATIC
+    ${deps}
+)
+target_include_directories(
+    stm32f1_bsp
+    PUBLIC
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/stm32f1_bsp/inc
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/stm32f1_bsp/core_inc
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys/inc
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/cpio
+
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/mlibc/arch/arm/
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/mlibc/arch/generic
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/mlibc/obj/src/internal
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/mlibc/src/include
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/mlibc/src/internal
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/mlibc/obj/include
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/mlibc/include
+)
+target_link_libraries(
+    stm32f1_bsp
+    PUBLIC
+    sys
+    muslc
+    cpio
+)
+add_dependencies(stm32f1_bsp sys)
+add_dependencies(stm32f1_bsp muslc)
+
+

mkrtos_user/lib/sys/inc/u_irq_sender.h

@@ -3,5 +3,5 @@
 #include "u_types.h"
 
 msg_tag_t uirq_bind(obj_handler_t obj_inx, umword_t irq_no, umword_t prio_sub_pre);
-msg_tag_t uirq_wait(obj_handler_t obj_inx);
+msg_tag_t uirq_wait(obj_handler_t obj_inx, int flags);
 msg_tag_t uirq_ack(obj_handler_t obj_inx, umword_t irq_no);

mkrtos_user/lib/sys/inc/u_sys.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "u_types.h"
-
+#include "u_prot.h"
 typedef struct sys_info
 {
     umword_t sys_tick;
@@ -9,3 +9,10 @@ typedef struct sys_info
 } sys_info_t;
 
 msg_tag_t sys_read_info(obj_handler_t obj, sys_info_t *info);
+
+#define sys_read_tick() ({          \
+    sys_info_t info;                \
+                                    \
+    sys_read_info(SYS_PROT, &info); \
+    info.sys_tick;                  \
+})

mkrtos_user/lib/sys/src/u_irq_sender.c

@@ -37,13 +37,13 @@ msg_tag_t uirq_bind(obj_handler_t obj_inx, umword_t irq_no, umword_t prio_sub_pr
 
     return tag;
 }
-msg_tag_t uirq_wait(obj_handler_t obj_inx)
+msg_tag_t uirq_wait(obj_handler_t obj_inx, int flags)
 {
     register volatile umword_t r0 asm("r0");
 
     syscall(syscall_prot_create(WAIT_IRQ, IRQ_PROT, obj_inx),
             0,
-            0,
+            flags,
             0,
             0,
             0,

mkrtos_user/lib/sys_svr/inc/ns_types.h

@@ -2,7 +2,7 @@
 #include "u_types.h"
 #include "u_rpc_svr.h"
 #define NAMESPACE_PATH_LEN 32
-#define NAMESAPCE_NR 32
+#define NAMESAPCE_NR 8
 
 typedef struct namespace_entry
 {

mkrtos_user/lib/sys_util/inc/u_drv.h

@@ -0,0 +1,4 @@
+
+#pragma once
+
+int u_drv_init(void);

mkrtos_user/lib/sys_util/inc/u_local_thread.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "u_types.h"
+#include "u_hd_man.h"
+
+int thread_create(int prio, void *(*fn)(void *arg), umword_t stack_top, obj_handler_t *ret_hd);

mkrtos_user/lib/sys_util/src/u_drv.c

@@ -0,0 +1,19 @@
+
+
+#include "u_types.h"
+#include "u_prot.h"
+#include "u_mm.h"
+#include "u_sleep.h"
+
+int u_drv_init(void)
+{
+    msg_tag_t tag;
+    u_sleep_init();
+
+    tag = mm_align_alloc(MM_PROT, (void *)0x40000000, 0x50000000 - 0x40000000);
+    if (msg_tag_get_val(tag) < 0)
+    {
+        return msg_tag_get_val(tag);
+    }
+    return 0;
+}

mkrtos_user/lib/sys_util/src/u_hd_man.c

@@ -7,9 +7,9 @@
 #include <pthread.h>
 
 #define HANDLER_START_INX 10 //!< fd开始的值，前10个内核保留
-#define HANDLER_MAX_NR 64   //!< 单个task最大支持的hd数量
+#define HANDLER_MAX_NR 96   //!< 单个task最大支持的hd数量
 
-static umword_t bitmap_handler_alloc[HANDLER_MAX_NR / WORD_BYTES];
+static umword_t bitmap_handler_alloc[HANDLER_MAX_NR / WORD_BITS];
 static pthread_spinlock_t lock;
 
 void hanlder_pre_alloc(obj_handler_t inx)
@@ -18,7 +18,7 @@ void hanlder_pre_alloc(obj_handler_t inx)
     umword_t word_offset = inx / WORD_BITS;
     umword_t bits_offset = inx % WORD_BITS;
 
-    if (word_offset >= (HANDLER_MAX_NR / WORD_BYTES))
+    if (word_offset >= (HANDLER_MAX_NR / WORD_BITS))
     {
         return;
     }
@@ -62,7 +62,7 @@ void handler_free(obj_handler_t hd_inx)
     umword_t word_offset = hd_inx / WORD_BITS;
     umword_t bits_offset = hd_inx % WORD_BITS;
 
-    if (word_offset >= (HANDLER_MAX_NR / WORD_BYTES))
+    if (word_offset >= (HANDLER_MAX_NR / WORD_BITS))
     {
         return;
     }

mkrtos_user/lib/sys_util/src/u_local_thread.c

@@ -0,0 +1,47 @@
+#include "u_log.h"
+#include "u_prot.h"
+#include "u_mm.h"
+#include "u_factory.h"
+#include "u_thread.h"
+#include "u_task.h"
+#include "u_ipc.h"
+#include "u_hd_man.h"
+#include <errno.h>
+
+int thread_create(int prio, void *(*fn)(void *arg), umword_t stack_top, obj_handler_t *ret_hd)
+{
+    obj_handler_t th1_hd;
+    th1_hd = handler_alloc();
+    if (th1_hd == HANDLER_INVALID)
+    {
+        return -ENOMEM;
+    }
+    msg_tag_t tag = factory_create_thread(FACTORY_PROT, vpage_create_raw3(KOBJ_ALL_RIGHTS, 0, th1_hd));
+    if (msg_tag_get_prot(tag) < 0)
+    {
+        return msg_tag_get_prot(tag);
+    }
+    tag = thread_exec_regs(th1_hd, (umword_t)fn, stack_top, RAM_BASE(), 0);
+    if (msg_tag_get_prot(tag) < 0)
+    {
+        handler_free_umap(th1_hd);
+        return msg_tag_get_prot(tag);
+    }
+    tag = thread_bind_task(th1_hd, TASK_THIS);
+    if (msg_tag_get_prot(tag) < 0)
+    {
+        handler_free_umap(th1_hd);
+        return msg_tag_get_prot(tag);
+    }
+    tag = thread_run(th1_hd, prio);
+    if (msg_tag_get_prot(tag) < 0)
+    {
+        handler_free_umap(th1_hd);
+        return msg_tag_get_prot(tag);
+    }
+    if (ret_hd)
+    {
+        *ret_hd = th1_hd;
+    }
+    return 0;
+}

mkrtos_user/lib/sys_util/src/u_sleep.c

@@ -7,11 +7,15 @@
 #include "u_factory.h"
 #include <sys/types.h>
 #include <assert.h>
-static obj_handler_t hd;
+static obj_handler_t hd = HANDLER_INVALID;
 void u_sleep_init(void)
 {
     msg_tag_t tag;
 
+    if (hd != HANDLER_INVALID)
+    {
+        return;
+    }
     hd = handler_alloc();
     assert(hd != HANDLER_INVALID);
     tag = factory_create_ipc(FACTORY_PROT, vpage_create_raw3(KOBJ_ALL_RIGHTS, 0, hd));

mkrtos_user/server/app/CMakeLists.txt

@@ -16,6 +16,7 @@ target_link_libraries(app.elf
     sys
     sys_util
     sys_svr
+    stm32f1_bsp
     ${GCC_LIB_PATH}/libgcc.a
 )
 target_include_directories(
@@ -35,8 +36,10 @@ target_include_directories(
     ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/mlibc/obj/include
     ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/mlibc/include
 
-    ${CMAKE_SOURCE_DIR}/mkrtos_user/server/app/bsp/core_inc
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/stm32f1_bsp/inc
-    ${CMAKE_SOURCE_DIR}/mkrtos_user/server/app/bsp/inc
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/stm32f1_bsp/core_inc
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/server/app/hmi_lcd
+    ${CMAKE_SOURCE_DIR}/mkrtos_user/server/app/util
 )
 add_dependencies(app.elf
 muslc

mkrtos_user/server/app/drv/adc.c

@@ -0,0 +1,80 @@
+
+#include "adc.h"
+
+#define ADC1_DR_Address ((uint32_t)0x4001244C)
+__IO uint16_t ADCConvertedValue[6];
+
+void adc_init(void)
+{
+    ADC_InitTypeDef ADC_InitStructure;
+    DMA_InitTypeDef DMA_InitStructure;
+    GPIO_InitTypeDef GPIO_InitStructure;
+    /* Enable DMA1 clock */
+    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
+
+    /* Enable ADC1 and GPIOC clock */
+    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE);
+
+    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
+    GPIO_Init(GPIOA, &GPIO_InitStructure);
+
+    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
+    GPIO_Init(GPIOB, &GPIO_InitStructure);
+    /* DMA1 channel1 configuration ----------------------------------------------*/
+    DMA_DeInit(DMA1_Channel1);
+    DMA_InitStructure.DMA_PeripheralBaseAddr = ADC1_DR_Address;
+    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)ADCConvertedValue;
+    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
+    DMA_InitStructure.DMA_BufferSize = 4;
+    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
+    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
+    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
+    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
+    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
+    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
+    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
+    DMA_Init(DMA1_Channel1, &DMA_InitStructure);
+
+    /* Enable DMA1 channel1 */
+    DMA_Cmd(DMA1_Channel1, ENABLE);
+
+    /* ADC1 configuration ------------------------------------------------------*/
+    ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
+    ADC_InitStructure.ADC_ScanConvMode = ENABLE;
+    ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
+    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
+    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
+    ADC_InitStructure.ADC_NbrOfChannel = 4;
+    ADC_Init(ADC1, &ADC_InitStructure);
+
+    /* ADC1 regular channels configuration */
+    ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_239Cycles5);
+    ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 2, ADC_SampleTime_239Cycles5);
+    ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 3, ADC_SampleTime_239Cycles5);
+    ADC_RegularChannelConfig(ADC1, ADC_Channel_9, 4, ADC_SampleTime_239Cycles5);
+    //	ADC_RegularChannelConfig(ADC1, ADC_Channel_6, 5, ADC_SampleTime_239Cycles5);
+    //	ADC_RegularChannelConfig(ADC1, ADC_Channel_7, 6, ADC_SampleTime_239Cycles5);
+
+    /* Enable ADC1 DMA */
+    ADC_DMACmd(ADC1, ENABLE);
+
+    /* Enable ADC1 */
+    ADC_Cmd(ADC1, ENABLE);
+
+    /* Enable ADC1 reset calibration register */
+    ADC_ResetCalibration(ADC1);
+    /* Check the end of ADC1 reset calibration register */
+    while (ADC_GetResetCalibrationStatus(ADC1))
+        ;
+
+    /* Start ADC1 calibration */
+    ADC_StartCalibration(ADC1);
+    /* Check the end of ADC1 calibration */
+    while (ADC_GetCalibrationStatus(ADC1))
+        ;
+
+    /* Start ADC1 Software Conversion */
+    ADC_SoftwareStartConvCmd(ADC1, ENABLE);
+}

mkrtos_user/server/app/drv/adc.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "stm32_sys.h"
+
+extern __IO uint16_t ADCConvertedValue[6];
+
+// 得到输出电压 mV
+#define ADC_OUT_V(a) (((a) / 4096.0f * 3300) * 2)
+
+void adc_init(void);
+

mkrtos_user/server/app/drv/drv.c

@@ -3,22 +3,34 @@
 #include "u_prot.h"
 #include "u_mm.h"
 #include "u_sleep.h"
+#include "u_drv.h"
+
 #include "led.h"
 #include "relay.h"
 #include "soft_iic.h"
 #include "spl06.h"
+#include "adc.h"
+#include "usart3.h"
+#include "usart2.h"
+#include "uart4.h"
+#include "uart5.h"
+#include "input_ck.h"
+#include "wk2xx_hw.h"
 #include <assert.h>
 
 void drv_init(void)
 {
-    msg_tag_t tag;
+    u_drv_init();
-    u_sleep_init();
-
-    tag = mm_align_alloc(MM_PROT, (void *)0x40000000, 0x50000000 - 0x40000000);
-    assert(msg_tag_get_val(tag) >= 0);
-
     led_init();
     relay_init();
     IIC_Init();
+    adc_init();
+    init_usart3(115200);
+    init_usart2(115200);
+    init_uart4(115200);
+    init_uart5(115200);
+    ext_input_check();
+    wk2xx_hw_init();
+
     spl0601_init();
 }

mkrtos_user/server/app/drv/input_ck.c

@@ -0,0 +1,18 @@
+
+#include "input_ck.h"
+#include "stm32_sys.h"
+void ext_input_check(void)
+{
+    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE);
+    PWR_BackupAccessCmd(ENABLE); /* 允许修改RTC和后备寄存器*/
+    RCC_LSEConfig(RCC_LSE_OFF);  /* 关闭外部低速时钟,PC14+PC15可以用作普通IO*/
+    BKP_TamperPinCmd(DISABLE);   /* 关闭入侵检测功能,PC13可以用作普通IO*/
+
+    GPIO_InitTypeDef GPIO_InitStructure;
+    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
+    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
+    GPIO_Init(GPIOC, &GPIO_InitStructure);
+
+    PWR_BackupAccessCmd(DISABLE); /* 禁止修改RTC和后备寄存器*/
+}

mkrtos_user/server/app/drv/input_ck.h

@@ -0,0 +1,2 @@
+
+void ext_input_check(void);

mkrtos_user/server/app/drv/spi2.c

@@ -0,0 +1,82 @@
+#include "spi2.h"
+#include "stm32_sys.h"
+// 以下是SPI模块的初始化代码，配置成主机模式，访问SD Card/W25Q64/NRF24L01
+// SPI口初始化
+// 这里针是对SPI2的初始化
+u8 SPI2_ReadWriteByte(u8 TxData);
+void SPI2_Init(void)
+{
+    GPIO_InitTypeDef GPIO_InitStructure;
+    SPI_InitTypeDef SPI_InitStructure;
+
+    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); // PORTB时钟使能
+    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);  // SPI3时钟使能
+
+    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
+    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);
+
+    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // PB3/4/5复用推挽输出
+    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
+    GPIO_Init(GPIOB, &GPIO_InitStructure); // 初始化GPIOB
+
+    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; // PB3/4/5复用推挽输出
+    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
+    GPIO_Init(GPIOB, &GPIO_InitStructure); // 初始化GPIOB
+
+    GPIO_SetBits(GPIOB, GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15); // PB3/4/5上拉
+
+    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; // 设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
+    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                      // 设置SPI工作模式:设置为主SPI
+    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                  // 设置SPI的数据大小:SPI发送接收8位帧结构
+    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;                         // 串行同步时钟的空闲状态为高电平
+    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;                       // 串行同步时钟的第二个跳变沿（上升或下降）数据被采样
+    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                          // NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
+    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; // 定义波特率预分频的值:波特率预分频值为256
+    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                 // 指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
+    SPI_InitStructure.SPI_CRCPolynomial = 7;                           // CRC值计算的多项式
+    SPI_Init(SPI2, &SPI_InitStructure);                                // 根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
+
+    SPI_Cmd(SPI2, ENABLE); // 使能SPI外设
+
+    SPI2_ReadWriteByte(0xff); // 启动传输
+}
+// SPI 速度设置函数
+// SpeedSet:
+// SPI_BaudRatePrescaler_2   2分频
+// SPI_BaudRatePrescaler_8   8分频
+// SPI_BaudRatePrescaler_16  16分频
+// SPI_BaudRatePrescaler_256 256分频
+
+void SPI2_SetSpeed(u8 SPI_BaudRatePrescaler)
+{
+    //  assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
+    SPI2->CR1 &= 0XFFC7;
+    SPI2->CR1 |= SPI_BaudRatePrescaler; // 设置SPI2速度
+    SPI_Cmd(SPI2, ENABLE);
+}
+
+// SPIx 读写一个字节
+// TxData:要写入的字节
+// 返回值:读取到的字节
+u8 SPI2_ReadWriteByte(u8 TxData)
+{
+    u8 retry = 0;
+    while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET) // 检查指定的SPI标志位设置与否:发送缓存空标志位
+    {
+        retry++;
+        if (retry > 200)
+            return 0;
+    }
+    SPI_I2S_SendData(SPI2, TxData); // 通过外设SPIx发送一个数据
+    retry = 0;
+
+    while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) // 检查指定的SPI标志位设置与否:接受缓存非空标志位
+    {
+        retry++;
+        if (retry > 200)
+            return 0;
+    }
+    return SPI_I2S_ReceiveData(SPI2); // 返回通过SPIx最近接收的数据
+}

mkrtos_user/server/app/drv/spi2.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "stm32_sys.h"
+
+#define SPI_CS_L() GPIO_ResetBits(GPIOB, GPIO_Pin_3)
+#define SPI_CS_H() GPIO_SetBits(GPIOB, GPIO_Pin_3)
+
+void SPI2_Init(void);             // 初始化SPI口
+void SPI2_SetSpeed(u8 SpeedSet);  // 设置SPI速度
+u8 SPI2_ReadWriteByte(u8 TxData); // SPI总线读写一个字节

mkrtos_user/server/app/drv/sysinfo.c

@@ -1,6 +1,12 @@
 #include "sysinfo.h"
+
+#include "fs_cli.h"
+#include <string.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <stddef.h>
 #include <pthread.h>
-sys_info_t sys_info = {0};
+uapp_sys_info_t sys_info = {0};
 
 static pthread_spinlock_t lock;
 
@@ -12,3 +18,42 @@ void sys_info_unlock(void)
 {
     pthread_spin_unlock(&lock);
 }
+
+int sys_info_save(void)
+{
+    int fd = fs_open("/sys_info.bin", O_CREAT | O_RDONLY, 0777);
+    if (fd < 0)
+    {
+        return fd;
+    }
+    sys_info_lock();
+    int wlen = fs_write(fd, &sys_info, sizeof(sys_info));
+    if (wlen != sizeof(sys_info))
+    {
+        sys_info_unlock();
+        fs_close(fd);
+        return -1;
+    }
+    sys_info_unlock();
+    fs_close(fd);
+    return 0;
+}
+int sys_info_read(void)
+{
+    int fd = fs_open("/sys_info.bin", O_CREAT | O_WRONLY, 0777);
+    if (fd < 0)
+    {
+        return fd;
+    }
+    sys_info_lock();
+    int wlen = fs_read(fd, &sys_info, sizeof(sys_info));
+    if (wlen != sizeof(sys_info))
+    {
+        sys_info_unlock();
+        fs_close(fd);
+        return -1;
+    }
+    sys_info_unlock();
+    fs_close(fd);
+    return 0;
+}

mkrtos_user/server/app/drv/sysinfo.h

@@ -1,4 +1,4 @@
-
+#pragma once
 #include "u_types.h"
 
 #define CTRL_IO_NUM 10
@@ -20,9 +20,12 @@ typedef struct
 
     uint8_t netID;
     uint8_t devID;
-} sys_info_t;
+} uapp_sys_info_t;
 
-extern sys_info_t sys_info;
+extern uapp_sys_info_t sys_info;
 
 void sys_info_lock(void);
 void sys_info_unlock(void);
+
+int sys_info_save(void);
+int sys_info_read(void);

mkrtos_user/server/app/drv/uart4.c

@@ -0,0 +1,109 @@
+
+#include "uart4.h"
+#include "cmd_queue.h"
+#include "u_factory.h"
+#include "u_irq_sender.h"
+#include "u_prot.h"
+#include "u_hd_man.h"
+#include "u_local_thread.h"
+#include "u_sleep.h"
+#include <assert.h>
+#include <fcntl.h>
+static obj_handler_t irq_obj;
+
+#define IRQ_THREAD_PRIO 3
+#define STACK_SIZE 512
+static __attribute__((aligned(8))) uint8_t stack0[STACK_SIZE];
+
+static void *UART4_IRQHandler(void *arg);
+
+void init_uart4(u32 baudRate)
+{
+    GPIO_InitTypeDef GPIO_InitStructure = {0};
+    USART_InitTypeDef USART_InitStructure = {0};
+    NVIC_InitTypeDef NVIC_InitStructure = {0};
+
+    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);  // 使能GPIOC时钟
+    RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE); // 使能串口3时钟
+
+    USART_DeInit(UART4);
+
+    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
+    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; // 设置PA2为复用推挽输出
+    GPIO_Init(GPIOC, &GPIO_InitStructure);
+    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; // 设置PA3为浮空输入
+    GPIO_Init(GPIOC, &GPIO_InitStructure);
+    GPIO_SetBits(GPIOC, GPIO_Pin_10);
+
+    USART_InitStructure.USART_BaudRate = baudRate;                                  // 设置串口波特率为115200
+    USART_InitStructure.USART_WordLength = USART_WordLength_8b;                     // 字长为8位数据格式
+    USART_InitStructure.USART_StopBits = USART_StopBits_1;                          // 1个停止位
+    USART_InitStructure.USART_Parity = USART_Parity_No;                             // 无奇偶校验位
+    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // 无硬件流控制
+    USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;                 // 发送和接收模式
+    USART_Init(UART4, &USART_InitStructure);                                       // 初始化串口
+
+    // NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
+    // NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; // 抢占优先级为1
+    // NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;        // 子优先级为1
+    // NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;           // IRQ通道使能
+    // NVIC_Init(&NVIC_InitStructure);                           // 中断优先级初始化
+
+    USART_Cmd(UART4, ENABLE);                     // 使能串口
+    USART_ITConfig(UART4, USART_IT_RXNE, ENABLE); // 开启中断
+    USART_ClearITPendingBit(UART4, USART_IT_RXNE);
+
+    irq_obj = handler_alloc();
+    assert(irq_obj != HANDLER_INVALID);
+    msg_tag_t tag = factory_create_irq_sender(FACTORY_PROT, vpage_create_raw3(0, 0, irq_obj));
+    assert(msg_tag_get_val(tag) >= 0);
+    uirq_bind(irq_obj, UART4_IRQn, (1 << 16) | 1);
+
+    int ret = thread_create(IRQ_THREAD_PRIO, UART4_IRQHandler, (umword_t)(stack0 + STACK_SIZE), NULL);
+    assert(ret >= 0);
+}
+static void *UART4_IRQHandler(void *arg)
+{
+    while (1)
+    {
+        msg_tag_t tag = uirq_wait(irq_obj, 0);
+        if (msg_tag_get_val(tag) >= 0)
+        {
+            if (USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)
+            {
+                USART_ClearITPendingBit(UART4, USART_IT_RXNE); // 清除中断标志
+                uint8_t data = USART_ReceiveData(UART4);
+                // queue_push(data);
+                // uart4_send_byte(data);
+            }
+            uirq_ack(irq_obj, UART4_IRQn);
+        }
+        // u_sleep_ms(1);
+    }
+    return NULL;
+}
+void uart4_send_byte(u8 byte)
+{
+    while (USART_GetFlagStatus(UART4, USART_FLAG_TXE) == RESET)
+        ;
+    USART_SendData(UART4, byte);
+    while (USART_GetFlagStatus(UART4, USART_FLAG_TXE) == RESET)
+        ;
+}
+void uart4_send_bytes(u8 *bytes, int len)
+{
+    int i;
+    for (i = 0; i < len; i++)
+    {
+        uart4_send_byte(bytes[i]);
+    }
+}
+void uart4_send_string(char *string)
+{
+    while (*string)
+    {
+        uart4_send_byte(*string++);
+    }
+}

mkrtos_user/server/app/drv/uart4.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "stm32_sys.h"
+void init_uart4(u32 baudRate);
+void uart4_send_string(char *string);
+void uart4_send_bytes(u8 *bytes, int len);
+void uart4_send_byte(u8 byte);