Merge pull request #19 from prife/simmerge

merge simulator for linux to master branch

bsp/simulator/SConstruct

@@ -18,38 +18,44 @@ else:
 sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')]
 from building import *
 
-TARGET = 'rtthread-win32.' + rtconfig.TARGET_EXT
 
 env = Environment()
 
 Export('RTT_ROOT')
 Export('rtconfig')
 
-libs = Split('''
-winmm
-gdi32
-winspool
-comdlg32
-advapi32
-shell32
-ole32
-oleaut32
-uuid
-odbc32
-odbccp32
-''')
-definitions = Split('''
-WIN32
-_DEBUG
-_CONSOLE
-MSVC
-_TIME_T_DEFINED
-''')
+if rtconfig.PLATFORM == 'cl':
+    TARGET = 'rtthread-win32.' + rtconfig.TARGET_EXT
+
+    libs = Split('''
+    winmm
+    gdi32
+    winspool
+    comdlg32
+    advapi32
+    shell32
+    ole32
+    oleaut32
+    uuid
+    odbc32
+    odbccp32
+    ''')
+    definitions = Split('''
+    WIN32
+    _DEBUG
+    _CONSOLE
+    MSVC
+    _TIME_T_DEFINED
+    ''')
+    env.Append(CCFLAGS=rtconfig.CFLAGS)
+    env.Append(LINKFLAGS=rtconfig.LFLAGS)
+    env['LIBS']=libs
+    env['CPPDEFINES']=definitions
+else:
+    TARGET = 'rtthread'
+    env.Append(CCFLAGS=rtconfig.CFLAGS)
+    env.Append(LINKFLAGS=rtconfig.LFLAGS)
 
-env.Append(CCFLAGS=rtconfig.CFLAGS)
-env.Append(LINKFLAGS=rtconfig.LFLAGS)
-env['LIBS']=libs
-env['CPPDEFINES']=definitions
 
 # prepare building environment
 

bsp/simulator/applications/SConscript

 from building import *
 
-cwd     = GetCurrentDir()
+cwd = GetCurrentDir()
 src	= Glob('*.c')
+
+# remove no need file.
+if GetDepend('RT_USING_DFS_WINSHAREDIR') == False:
+    SrcRemove(src, 'dfs_win32.c')
 CPPPATH = [cwd, str(Dir('#'))]
 
 group = DefineGroup('Applications', src, depend = [''], CPPPATH = CPPPATH)

bsp/simulator/applications/application.c

@@ -18,6 +18,7 @@
 
 #include <components.h>
 
+
 void rt_init_thread_entry(void *parameter)
 {
 #ifdef RT_USING_LWIP
@@ -49,7 +50,11 @@ void rt_init_thread_entry(void *parameter)
 
 #ifdef RT_USING_DFS_ELMFAT
         /* mount sd card fatfs as root directory */
+#ifdef _WIN32
         if (dfs_mount("sd0", "/disk/sd", "elm", 0, 0) == 0)
+#else
+        if (dfs_mount("sd0", "/", "elm", 0, 0) == 0)
+#endif
             rt_kprintf("fatfs initialized!\n");
         else
             rt_kprintf("fatfs initialization failed!\n");
@@ -73,31 +78,19 @@ void rt_init_thread_entry(void *parameter)
 
     }
 #endif
-
-#if 0
-    {
-        extern void application_init(void);
-        rt_thread_delay(RT_TICK_PER_SECOND);
-        application_init();
-    }
-#endif
-
-#if defined(RT_USING_RTGUI)
-    rt_thread_delay(3000);
-    snake_main();
-#endif
 }
 
 static void rt_test_thread_entry(void *parameter)
 {
     int i;
-    for (i = 0; i < 10; i++)
+    for (i = 0; i < 5; i++)
     {
         rt_kprintf("hello, world\n");
-        rt_thread_delay(100);
+        rt_thread_delay(RT_TICK_PER_SECOND);
     }
 }
 
+
 int rt_application_init()
 {
     rt_thread_t tid;
@@ -118,5 +111,4 @@ int rt_application_init()
     return 0;
 }
 
-
 /*@}*/

bsp/simulator/drivers/board.c

@@ -16,7 +16,6 @@
 #include <rtthread.h>
 #include "board.h"
 #include <stdlib.h>
-#include <windows.h>
 
 /**
  * @addtogroup simulator on win32
@@ -30,29 +29,56 @@ rt_uint8_t *rt_hw_sram_init(void)
     if (heap == RT_NULL)
     {
         rt_kprintf("there is no memory in pc.");
+#ifdef _WIN32
         _exit(1);
+#else
+        exit(1);
+#endif
     }
     return heap;
 }
 
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
 void rt_hw_win32_low_cpu(void)
 {
+#ifdef _WIN32
+    /* in windows */
     Sleep(1000);
+#else
+    /* in linux */
+    sleep(1);
+#endif
 }
 
-#if defined(RT_USING_FINSH)
-
+#ifdef _WIN32
 #ifndef _CRT_TERMINATE_DEFINED
 #define _CRT_TERMINATE_DEFINED
 _CRTIMP __declspec(noreturn) void __cdecl exit(__in int _Code);
 _CRTIMP __declspec(noreturn) void __cdecl _exit(__in int _Code);
 _CRTIMP void __cdecl abort(void);
 #endif
+#endif
 
+#if defined(RT_USING_FINSH)
 #include <finsh.h>
 void rt_hw_exit(void)
 {
     rt_kprintf("RT-Thread, bye\n");
+#if !defined(_WIN32) && defined(__GNUC__)
+    /* *
+     * getchar reads key from buffer, while finsh need an non-buffer getchar
+     * in windows, getch is such an function, in linux, we had to change
+     * the behaviour of terminal to get an non-buffer getchar.
+     * in usart_sim.c, set_stty is called to do this work
+     * */
+    {
+        extern void restore_stty(void);
+        restore_stty();
+    }
+#endif
     exit(0);
 }
 FINSH_FUNCTION_EXPORT_ALIAS(rt_hw_exit, exit, exit rt - thread);
@@ -66,8 +92,11 @@ void rt_hw_board_init()
     /* init system memory */
     heap = rt_hw_sram_init();
 
-#if defined(RT_USING_CONSOLE)
+//#if defined(RT_USING_USART)
     rt_hw_usart_init();
+//#endif
+
+#if defined(RT_USING_CONSOLE)
     rt_hw_serial_init();
     rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
 #endif

bsp/simulator/drivers/sd_sim.c

 #include <rtthread.h>
 #include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+//#include <stdlib.h>
+//#include <string.h>
 #include <dfs_def.h>
 
 // #define SD_TRACE     rt_kprintf

bsp/simulator/drivers/sdl_fb.c

 #include <rtthread.h>
 
+#ifdef _WIN32
 #include <sdl.h>
+#else
+#include <SDL/SDL.h>
+#endif
 #include <rtdevice.h>
 #include <rtgui/driver.h>
 
@@ -104,7 +108,7 @@ static void sdlfb_hw_init(void)
     //_putenv("SDL_VIDEODRIVER=windib");
 
     //if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_AUDIO) < 0)
-    if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
+    if (SDL_Init(SDL_INIT_VIDEO) < 0)
     {
         fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
         exit(1);
@@ -132,16 +136,24 @@ static void sdlfb_hw_init(void)
     sdllock = rt_mutex_create("fb", RT_IPC_FLAG_FIFO);
 }
 
+#ifdef _WIN32
 #include  <windows.h>
 #include  <mmsystem.h>
+#else
+#include <pthread.h>
+#endif
+
 #include  <stdio.h>
-#include <sdl.h>
 #include <rtgui/event.h>
 #include <rtgui/kbddef.h>
 #include <rtgui/rtgui_server.h>
 #include <rtgui/rtgui_system.h>
 
+#ifdef _WIN32
 static DWORD WINAPI sdl_loop(LPVOID lpParam)
+#else
+static void *sdl_loop(void *lpParam)
+#endif
 {
     int quit = 0;
     SDL_Event event;
@@ -284,6 +296,7 @@ static DWORD WINAPI sdl_loop(LPVOID lpParam)
 /* start sdl thread */
 void rt_hw_sdl_start(void)
 {
+#ifdef _WIN32
     HANDLE thread;
     DWORD  thread_id;
 
@@ -301,4 +314,15 @@ void rt_hw_sdl_start(void)
         return;
     }
     ResumeThread(thread);
+#else
+	/* Linux */
+	pthread_t pid;
+    int res;
+    res = pthread_create(&pid, NULL, &sdl_loop, NULL);
+    if (res)
+    {
+        printf("pthread create sdl thread faild, <%d>\n", res);
+        exit(EXIT_FAILURE);
+	}
+#endif
 }

bsp/simulator/drivers/serial.c

@@ -13,8 +13,12 @@
 #include "serial.h"
 #include <stdio.h>
 struct rt_device serial_device;
-extern struct serial_int_rx serial_rx;
+//extern struct serial_int_rx serial_rx;
+struct serial_int_rx serial_rx;
+
+#if 0
 static FILE *fp = RT_NULL;
+#endif
 
 /*@{*/
 
@@ -109,13 +113,16 @@ static rt_size_t rt_serial_write(rt_device_t dev, rt_off_t pos, const void *buff
 #if _DEBUG_SERIAL==1
     printf("in rt_serial_write()\n");
 #endif
+#if 0
     if (fp == NULL)
         fp = fopen("log.txt", "wb+");
 
     if (fp != NULL)
         fwrite(buffer, size, 1, fp);
+#endif
 
     printf("%s", (char *)buffer);
+	fflush(stdout);
     return size;
 }
 

bsp/simulator/drivers/usart_sim.c

 #include  <rthw.h>
 #include  <rtthread.h>
+
+#ifdef _WIN32
 #include  <windows.h>
 #include  <mmsystem.h>
-#include  <stdio.h>
 #include  <conio.h>
+#endif
 
+#include  <stdio.h>
 #include "serial.h"
 
 struct serial_int_rx serial_rx;
 extern struct rt_device serial_device;
 
+#ifdef _WIN32
 /*
  * Handler for OSKey Thread
  */
@@ -19,7 +23,6 @@ static DWORD        OSKey_ThreadID;
 static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam);
 void rt_hw_usart_init(void)
 {
-
     /*
      * create serial thread that receive key input from keyboard
      */
@@ -46,9 +49,31 @@ void rt_hw_usart_init(void)
      * Start OS get key Thread
      */
     ResumeThread(OSKey_Thread);
-
 }
 
+#else /* POSIX version */
+
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <termios.h> /* for tcxxxattr, ECHO, etc */
+#include <unistd.h> /* for STDIN_FILENO */
+
+
+static void * ThreadforKeyGet(void * lpParam);
+static pthread_t OSKey_Thread;
+void rt_hw_usart_init(void)
+{
+    int res;
+    res = pthread_create(&OSKey_Thread, NULL, &ThreadforKeyGet, NULL);
+    if (res)
+    {
+        printf("pthread create faild, <%d>\n", res);
+        exit(EXIT_FAILURE);
+    }
+}
+#endif
 /*
  * 方向键(←)： 0xe04b
  * 方向键(↑)： 0xe048
@@ -100,15 +125,48 @@ static int savekey(unsigned char key)
     }
     return 0;
 }
+#ifdef _WIN32
 static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam)
+#else
+
+static struct termios oldt, newt;
+/*simulate windows' getch(), it works!!*/
+void set_stty(void)
+{
+	/* get terminal input's attribute */
+    tcgetattr(STDIN_FILENO, &oldt);
+    newt = oldt;
+
+	/* set termios' local mode */
+    newt.c_lflag &= ~(ECHO|ICANON);
+    tcsetattr(STDIN_FILENO, TCSANOW, &newt);
+}
+
+void restore_stty(void)
+{
+   /* recover terminal's attribute */
+   tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
+}
+
+#define getch  getchar
+
+static void * ThreadforKeyGet(void * lpParam)
+#endif /* not _WIN32*/
 {
     unsigned char key;
 
+#ifndef _WIN32
+    sigset_t  sigmask, oldmask;
+	/* set the getchar without buffer */
+	sigfillset(&sigmask);
+	pthread_sigmask(SIG_BLOCK, &sigmask, &oldmask);
+	set_stty();
+#endif
     (void)lpParam;              //prevent compiler warnings
-
     for (;;)
     {
         key = getch();
+#ifdef _WIN32
         if (key == 0xE0)
         {
             key = getch();
@@ -128,7 +186,7 @@ static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam)
 
             continue;
         }
-
+#endif
         savekey(key);
     }
-} /*** ThreadforKeyGet ***/
\ No newline at end of file
+} /*** ThreadforKeyGet ***/

bsp/simulator/rtconfig.h

@@ -2,15 +2,15 @@
 #ifndef __RTTHREAD_CFG_H__
 #define __RTTHREAD_CFG_H__
 
+#define RT_HEAP_SIZE   (1024*1024*2)
+
+#if  defined(_MSC_VER)
 /* SECTION: port for visual studio */
-#ifdef _MSC_VER
 #undef RT_USING_NEWLIB
 #undef RT_USING_MINILIBC
 #define NORESOURCE  //RT_VESRION in winuser.h
 #define _CRT_ERRNO_DEFINED  //errno macro redefinition
 
-#define RT_HEAP_SIZE   (1024*1024*2)
-
 /* disable some warning in MSC */
 #pragma warning(disable:4273)	/* to ignore: warning C4273: inconsistent dll linkage */
 #pragma warning(disable:4312)   /* to ignore: warning C4312: 'type cast' : conversion from 'rt_uint32_t' to 'rt_uint32_t *' */
@@ -18,6 +18,9 @@
 #pragma warning(disable:4996)   /* to ignore: warning C4996: The POSIX name for this item is deprecated. */
 #pragma warning(disable:4267)   /* to ignore: warning C4267: conversion from 'size_t' to 'rt_size_t', possible loss of data */
 #pragma warning(disable:4244)   /* to ignore: warning C4244: '=' : conversion from '__w64 int' to 'rt_size_t', possible loss of data */
+
+#elif defined(__GNUC__)
+#define RT_USING_NOLIBC
 #endif
 
 /* SECTION: basic kernel options */
@@ -31,11 +34,12 @@
 #define RT_THREAD_PRIORITY_MAX  32	
 
 /* Tick per Second */
-#define RT_TICK_PER_SECOND	1000
+#define RT_TICK_PER_SECOND	100
 
 /* SECTION: RT_DEBUG */
 /* Thread Debug */
 #define RT_DEBUG
+//#define RT_DEBUG_SCHEDULER   1
 #define RT_THREAD_DEBUG
 
 #define RT_USING_OVERFLOW_CHECK
@@ -129,11 +133,11 @@
 /* #define RT_UFFS_USE_CHECK_MARK_FUNCITON */
 
 /* DFS: JFFS2 nor flash file system options */
-#define RT_USING_DFS_JFFS2
+//#define RT_USING_DFS_JFFS2
 
 /* DFS: windows share directory mounted to rt-thread/dfs  */
 /* only used in bsp/simulator */
-#define RT_USING_DFS_WINSHAREDIR
+//#define RT_USING_DFS_WINSHAREDIR
 
 /* the max number of mounted file system */
 #define DFS_FILESYSTEMS_MAX			4

bsp/simulator/rtconfig.py

 # toolchains options
 ARCH='sim'
-CPU='win32' #CPU='posix'
-CROSS_TOOL='msvc' #win32
+#CPU='win32'
+#CPU='posix'
+CPU='posix'
+CROSS_TOOL='gcc' #msvc # gcc
 
 # lcd panel options
 # 'FMT0371','ILI932X', 'SSD1289'
@@ -33,16 +35,19 @@ if PLATFORM == 'gcc':
     OBJCPY = PREFIX + 'objcopy'
 
     DEVICE = ' -ffunction-sections -fdata-sections'
-    CFLAGS = DEVICE
+    DEVICE = '  '
+    CFLAGS = DEVICE + ' -I/usr/include -w -D_REENTRANT'
     AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp'
     #LFLAGS = DEVICE + ' -Wl,--gc-sections,-Map=rtthread-linux.map,-cref,-u,Reset_Handler -T stm32_rom.ld'
-    LFLAGS = DEVICE + ' -Wl,--gc-sections,-Map=rtthread-linux.map -lpthread'
+    #LFLAGS = DEVICE + ' -Wl,--gc-sections,-Map=rtthread-linux.map -lpthread'
+    #LFLAGS = DEVICE + ' -Wl,--gc-sections,-Map=rtthread-linux.map -pthread'
+    LFLAGS = DEVICE + ' -Wl,-Map=rtthread-linux.map -pthread -T gcc.ld'
 
     CPATH = ''
     LPATH = ''
 
     if BUILD == 'debug':
-        CFLAGS += ' -O0 -gdwarf-2'
+        CFLAGS += ' -g -O0 -gdwarf-2'
         AFLAGS += ' -gdwarf-2'
     else:
         CFLAGS += ' -O2'

libcpu/sim/posix/cpu_port.c

+/*
+ * author : prife (goprife@gmail.com)
+ * date   : 2013/01/14 01:18:50
+ * version: v 0.2.0
+ */
+#include <rtthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <signal.h>
+#include <unistd.h>
+#include <semaphore.h>
+#include <time.h>
+#include <sys/time.h>
+
+//#define TRACE       printf
+#define TRACE(...)
+
+typedef struct _thread
+{
+    pthread_t pthread;
+    void (*task)(void *);
+    void *para;
+    void (*exit)(void);
+    sem_t sem;
+    rt_thread_t rtthread;
+    int status;
+    void *data;
+} thread_t;
+
+#define THREAD_T(thread)  ((thread_t *)thread)
+
+#define MSG_SUSPEND  SIGUSR1    /* 10 */
+#define MSG_RESUME   SIGUSR2
+#define MSG_TICK     SIGALRM    /* 14 */
+#define TIMER_TYPE   ITIMER_REAL
+#define MAX_INTERRUPT_NUM ((unsigned int)sizeof(unsigned int) * 8)
+
+#define INTERRUPT_ENABLE   0
+#define INTERRUPT_DISABLE  1
+
+/* 线程挂起状态，共两种取值 */
+#define SUSPEND_LOCK      0
+#define SUSPEND_SIGWAIT   1
+#define THREAD_RUNNING    2
+
+/* interrupt flag, if 1, disable, if 0, enable */
+static long interrupt_disable_flag;
+//static int systick_signal_flag;
+
+/* flag in interrupt handling */
+rt_uint32_t rt_interrupt_from_thread, rt_interrupt_to_thread;
+rt_uint32_t rt_thread_switch_interrupt_flag;
+
+/* interrupt event mutex */
+static pthread_mutex_t *ptr_int_mutex;
+static pthread_cond_t cond_int_hit; /* interrupt occured! */
+static volatile unsigned int  cpu_pending_interrupts;
+static int (* cpu_isr_table[MAX_INTERRUPT_NUM])(void) = {0};
+
+static pthread_t mainthread_pid;
+
+/* function definition */
+static void start_sys_timer(void);
+static int tick_interrupt_isr(void);
+static void mthread_signal_tick(int sig);
+static int mainthread_scheduler(void);
+
+int signal_install(int sig, void (*func)(int))
+{
+    struct sigaction act;
+
+    /* set the signal handler */
+    act.sa_handler = func ;
+    sigemptyset(&act.sa_mask);
+    act.sa_flags = 0;
+    sigaction(sig, &act, 0);
+}
+
+int signal_mask(void)
+{
+    sigset_t  sigmask, oldmask;
+
+    /* set signal mask */
+    sigemptyset(&sigmask);
+    sigaddset(&sigmask, SIGALRM);
+    pthread_sigmask(SIG_BLOCK, &sigmask, &oldmask);
+}
+static void thread_suspend_signal_handler(int sig)
+{
+    sigset_t sigmask;
+    pthread_t pid = pthread_self();
+    thread_t *thread_from;
+    thread_t *thread_to;
+    rt_thread_t tid;
+
+    if (sig != MSG_SUSPEND)
+    {
+        printf("get an unexpected signal <%d>, exit\n", sig);
+        exit(EXIT_FAILURE);
+    }
+
+    thread_from = (thread_t *) rt_interrupt_from_thread;
+    thread_to = (thread_t *) rt_interrupt_to_thread;
+
+    /* 注意！此时 rt_thread_self的值是to线程的值！ */
+    tid = rt_thread_self();
+    /* FIXME RT_ASSERT(thread_from->pthread == pid); */
+    RT_ASSERT((thread_t *)(tid->sp) == thread_to);
+
+    TRACE("signal: SIGSUSPEND suspend <%s>\n", thread_from->rtthread->name);
+
+    /* 使用sigwait或者sigsuspend来挂起from线程  */
+    //sem_wait(&thread_from->sem);
+    sigemptyset(&sigmask);
+    sigaddset(&sigmask, MSG_RESUME);
+
+    /* Beginnig Linux Programming上说，当信号处理函数运行中，此信号就会被屏蔽，
+     * 以防止重复执行信号处理函数
+     */
+    thread_from->status = SUSPEND_SIGWAIT;
+    if (sigwait(&sigmask, &sig) != 0)
+    {
+        printf("sigwait faild, %d\n", sig);
+    }
+    thread_to = (thread_t *) rt_interrupt_to_thread;
+    RT_ASSERT(thread_to == thread_from);
+    thread_to->status = THREAD_RUNNING;
+    TRACE("signal: SIGSUSPEND resume  <%s>\n", thread_from->rtthread->name);
+}
+
+static void thread_resume_signal_handler(int sig)
+{
+    sigset_t sigmask;
+    pthread_t pid = pthread_self();
+    thread_t *thread_from;
+    thread_t *thread_to;
+    rt_thread_t tid;
+
+    thread_from = (thread_t *) rt_interrupt_from_thread;
+    thread_to = (thread_t *) rt_interrupt_to_thread;
+
+    /* 注意！此时 rt_thread_self的值是to线程的值！ */
+    tid = rt_thread_self();
+    RT_ASSERT((thread_t *)(tid->sp) == thread_to);
+
+    TRACE("signal: SIGRESUME resume  <%s>\n", thread_to->rtthread->name);
+}
+
+static void *thread_run(void *parameter)
+{
+    rt_thread_t tid;
+    thread_t *thread;
+    thread = THREAD_T(parameter);
+    int res;
+
+    /* set signal mask, mask the timer! */
+    signal_mask();
+
+    thread->status = SUSPEND_LOCK;
+    TRACE("pid <%08x> stop on sem...\n", (unsigned int)(thread->pthread));
+    sem_wait(&thread->sem);
+
+    tid = rt_thread_self();
+    TRACE("pid <%08x> tid <%s> starts...\n", (unsigned int)(thread->pthread),
+          tid->name);
+    thread->rtthread = tid;
+    thread->task(thread->para);
+    TRACE("pid <%08x> tid <%s> exit...\n", (unsigned int)(thread->pthread),
+          tid->name);
+    thread->exit();
+
+    /*TODO:
+     * 最后一行的pthread_exit永远没有机会执行，这是因为在threead->exit函数中
+     * 会发生线程切换，并永久将此pthread线程挂起，所以更完美的解决方案是在这
+	 * 里发送信号给主线程，主线程中再次唤醒此线程令其自动退出。
+	 */
+    //sem_destroy(&thread->sem);
+
+    pthread_exit(NULL);
+}
+static int thread_create(
+    thread_t *thread, void *task, void *parameter, void *pexit)
+{
+    int res;
+    pthread_attr_t attr;
+
+    thread->task = task;
+    thread->para = parameter;
+    thread->exit = pexit;
+
+    if (sem_init(&thread->sem, 0, 0) != 0)
+    {
+        printf("init thread->sem failed, exit \n");
+        exit(EXIT_FAILURE);
+    }
+    /* No need to join the threads. */
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+
+    /* create a posix thread */
+    res = pthread_create(&thread->pthread, &attr, &thread_run, (void *)thread);
+    if (res)
+    {
+        printf("pthread create faild, <%d>\n", res);
+        exit(EXIT_FAILURE);
+    }
+
+    return 0;
+}
+
+/* resume the thread */
+static int thread_resume(thread_t *thread)
+{
+    sem_post(& thread->sem);
+}
+
+
+rt_uint8_t *rt_hw_stack_init(
+    void *pEntry,
+    void *pParam,
+    rt_uint8_t *pStackAddr,
+    void *pExit)
+{
+    thread_t *thread;
+
+    thread = (thread_t *)(pStackAddr - sizeof(thread_t));
+
+    /* set the filed to zero */
+    memset(thread, 0x00, sizeof(thread_t));
+
+    thread_create(thread, pEntry, pParam, pExit);
+    //TRACE("thread %x created\n", (unsigned int)thread_table[t].pthread);
+
+    return (rt_uint8_t *) thread;
+}
+
+rt_base_t rt_hw_interrupt_disable(void)
+{
+    long back;
+
+    if (ptr_int_mutex == NULL)
+    {
+        return 0;
+    }
+
+    pthread_mutex_lock(ptr_int_mutex);
+    back = interrupt_disable_flag;
+    interrupt_disable_flag = INTERRUPT_DISABLE;
+
+    /*TODO: It may need to unmask the signal */
+    return back;
+}
+
+void rt_hw_interrupt_enable(rt_base_t level)
+{
+    struct rt_thread * tid;
+    pthread_t pid;
+    thread_t *thread_from;
+    thread_t *thread_to;
+
+    if (ptr_int_mutex == NULL)
+        return;
+
+    interrupt_disable_flag = level;
+
+    pthread_mutex_unlock(ptr_int_mutex);
+    /* 如果已经中断仍然关闭 */
+    if (interrupt_disable_flag)
+    {
+        return;
+    }
+
+    /* 表示当前中断打开, 检查是否有挂起的中断 */
+    pthread_mutex_lock(ptr_int_mutex);
+    if (!cpu_pending_interrupts)
+    {
+        pthread_mutex_unlock(ptr_int_mutex);
+        return;
+    }
+
+    thread_from = (thread_t *) rt_interrupt_from_thread;
+    thread_to = (thread_t *) rt_interrupt_to_thread;
+    tid = rt_thread_self();
+    pid = pthread_self();
+
+    //pid != mainthread_pid &&
+    if (thread_from->pthread == pid)
+    {
+        /* 注意这段代码是在RTT普通线程函数总函数中执行的，
+         * from线程就是当前rtt线程 */
+        /* 需要检查是否有挂起的中断需要处理 */
+        TRACE("conswitch: P in pid<%x> ,suspend <%s>, resume <%s>!\n",
+              (unsigned int)pid,
+              thread_from->rtthread->name,
+              thread_to->rtthread->name);
+
+        cpu_pending_interrupts --;
+        thread_from->status = SUSPEND_LOCK;
+        pthread_mutex_unlock(ptr_int_mutex);
+        /* 唤醒被挂起的线程 */
+        if (thread_to->status == SUSPEND_SIGWAIT)
+        {
+            pthread_kill(thread_to->pthread, MSG_RESUME);
+        }
+        else if (thread_to->status == SUSPEND_LOCK)
+        {
+            sem_post(& thread_to->sem);
+        }
+        else
+        {
+            printf("conswitch: should not be here! %d\n", __LINE__);
+            exit(EXIT_FAILURE);
+        }
+
+        /* 挂起当前的线程 */
+        sem_wait(& thread_from->sem);
+        pthread_mutex_lock(ptr_int_mutex);
+        thread_from->status = THREAD_RUNNING;
+        pthread_mutex_unlock(ptr_int_mutex);
+    }
+    else
+    {
+        /* 注意这段代码可能在多种情况下运行：
+         * 1. 在system tick中执行， 即主线程的SIGALRM信号处理函数中执行
+         * 2. 其他线程中调用，比如用于获取按键输入的线程中调用
+         */
+        TRACE("conswitch: S in pid<%x>  ,suspend <%s>, resume <%s>!\n",
+              (unsigned int)pid,
+              thread_from->rtthread->name,
+              thread_to->rtthread->name);
+
+        cpu_pending_interrupts --;
+
+        /* 需要把解锁函数放在前面,以防止死锁？？ */
+        pthread_mutex_unlock(ptr_int_mutex);
+
+        /* 挂起from线程 */
+        pthread_kill(thread_from->pthread, MSG_SUSPEND);
+        /* 注意：这里需要确保线程被挂起了, 否则312行就很可能就会报错退出
+         * 因为这里挂起线程是通过信号实现的，所以一定要确保线程挂起才行 */
+        while (thread_from->status != SUSPEND_SIGWAIT)
+        {
+            sched_yield();
+        }
+
+        /* 唤醒to线程 */
+        if (thread_to->status == SUSPEND_SIGWAIT)
+        {
+            pthread_kill(thread_to->pthread, MSG_RESUME);
+        }
+        else if (thread_to->status == SUSPEND_LOCK)
+        {
+            sem_post(& thread_to->sem);
+        }
+        else
+        {
+            printf("conswitch: should not be here! %d\n", __LINE__);
+            exit(EXIT_FAILURE);
+        }
+
+    }
+    /*TODO: It may need to unmask the signal */
+}
+
+void rt_hw_context_switch_interrupt(rt_uint32_t from,
+                                    rt_uint32_t to)
+{
+    rt_hw_context_switch(from, to);
+}
+
+void rt_hw_context_switch(rt_uint32_t from,
+                          rt_uint32_t to)
+{
+    struct rt_thread * tid;
+    pthread_t pid;
+    thread_t *thread_from;
+    thread_t *thread_to;
+
+    RT_ASSERT(from != to);
+
+#if 0
+    //TODO: 可能还需要考虑嵌套切换的情况
+    if (rt_thread_switch_interrupt_flag != 1)
+    {
+        rt_thread_switch_interrupt_flag = 1;
+
+        // set rt_interrupt_from_thread
+        rt_interrupt_from_thread = *((rt_uint32_t *)from);
+    }
+#endif
+    pthread_mutex_lock(ptr_int_mutex);
+    rt_interrupt_from_thread = *((rt_uint32_t *)from);
+    rt_interrupt_to_thread = *((rt_uint32_t *)to);
+
+    /* 这个函数只是并不会真正执行中断处理函数，而只是简单的
+     * 设置一下中断挂起标志位
+     */
+    cpu_pending_interrupts ++;
+    pthread_mutex_unlock(ptr_int_mutex);
+}
+
+void rt_hw_context_switch_to(rt_uint32_t to)
+{
+    //set to thread
+    rt_interrupt_to_thread = *((rt_uint32_t *)(to));
+
+    //clear from thread
+    rt_interrupt_from_thread = 0;
+
+    //set interrupt to 1
+    rt_thread_switch_interrupt_flag = 0; //TODO: 还需要考虑这个嵌套切换的情况
+
+    /* enable interrupt
+     * note: NOW, there are only one interrupt in simposix: system tick */
+    rt_hw_interrupt_enable(0);
+
+    //start the main thread scheduler
+    mainthread_scheduler();
+
+    //never reach here!
+    return;
+}
+
+static int mainthread_scheduler(void)
+{
+    int i, res, sig;
+    thread_t *thread_from;
+    thread_t *thread_to;
+    pthread_mutex_t mutex;
+    pthread_mutexattr_t mutexattr;
+    sigset_t  sigmask, oldmask;
+
+    /* save the main thread id */
+    mainthread_pid = pthread_self();
+    TRACE("pid <%08x> mainthread\n", (unsigned int)(mainthread_pid));
+
+    /* 屏蔽suspend信号和resume信号 */
+    sigemptyset(&sigmask);
+    sigaddset(&sigmask, MSG_SUSPEND);
+    sigaddset(&sigmask, MSG_RESUME);
+    pthread_sigmask(SIG_BLOCK, &sigmask, &oldmask);
+
+    sigemptyset(&sigmask);
+    sigaddset(&sigmask, SIGALRM);
+
+    /* install signal handler of system tick */
+    signal_install(SIGALRM, mthread_signal_tick);
+    /* install signal handler used to suspend/resume threads */
+    signal_install(MSG_SUSPEND, thread_suspend_signal_handler);
+    signal_install(MSG_RESUME, thread_resume_signal_handler);
+
+    /* create a mutex and condition val, used to indicate interrupts occrue */
+    ptr_int_mutex = &mutex;
+    pthread_mutexattr_init(&mutexattr);
+    pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE_NP);
+    pthread_mutex_init(ptr_int_mutex, &mutexattr);
+
+    /* start timer */
+    start_sys_timer();
+
+    thread_to = (thread_t *) rt_interrupt_to_thread;
+    thread_resume(thread_to);
+    for (;;)
+    {
+#if 1
+        if (sigwait(&sigmask, &sig) != 0)
+        {
+            printf("mthread: sigwait get unexpected sig %d\n", sig);
+        }
+#else
+        pause();
+#endif
+        TRACE("mthread:got sig %d\n", sig);
+        /* signal mask sigalrm  屏蔽SIGALRM信号 */
+        pthread_sigmask(SIG_BLOCK, &sigmask, &oldmask);
+
+        // if (systick_signal_flag != 0)
+        if (pthread_mutex_trylock(ptr_int_mutex) == 0)
+        {
+            tick_interrupt_isr();
+            // systick_signal_flag = 0;
+            pthread_mutex_unlock(ptr_int_mutex);
+        }
+        else
+        {
+            TRACE("try lock failed.\n");
+        }
+
+        /* 开启SIGALRM信号 */
+        pthread_sigmask(SIG_UNBLOCK, &sigmask, &oldmask);
+    }
+
+    return 0;
+}
+
+/*
+ * Setup the systick timer to generate the tick interrupts at the required
+ * frequency.
+ */
+static void start_sys_timer(void)
+{
+    struct itimerval itimer, oitimer;
+    int us;
+
+    RT_ASSERT(RT_TICK_PER_SECOND <= 1000000 || RT_TICK_PER_SECOND >= 1);
+
+    us = 1000000 / RT_TICK_PER_SECOND - 1;
+
+    TRACE("start system tick!\n");
+    /* Initialise the structure with the current timer information. */
+    if (0 != getitimer(TIMER_TYPE, &itimer))
+    {
+        TRACE("get timer failed.\n");
+        exit(EXIT_FAILURE);
+    }
+
+    /* Set the interval between timer events. */
+    itimer.it_interval.tv_sec = 0;
+    itimer.it_interval.tv_usec = us;
+    /* Set the current count-down. */
+    itimer.it_value.tv_sec = 0;
+    itimer.it_value.tv_usec = us;
+
+    /* Set-up the timer interrupt. */
+    if (0 != setitimer(TIMER_TYPE, &itimer, &oitimer))
+    {
+        TRACE("set timer failed.\n");
+        exit(EXIT_FAILURE);
+    }
+}
+
+static void mthread_signal_tick(int sig)
+{
+    int res;
+    pthread_t pid = pthread_self();
+
+    if (sig == SIGALRM)
+    {
+        TRACE("pid <%x> signal: SIGALRM enter!\n", (unsigned int)pid);
+        //systick_signal_flag = 1;
+        TRACE("pid <%x> signal: SIGALRM leave!\n", (unsigned int)pid);
+    }
+    else
+    {
+        TRACE("got an unexpected signal <%d>\n", sig);
+        exit(EXIT_FAILURE);
+    }
+}
+
+/* isr return value: 1, should not be masked, if 0, can be masked */
+static int tick_interrupt_isr(void)
+{
+    TRACE("isr: systick enter!\n");
+    /* enter interrupt */
+    rt_interrupt_enter();
+
+    rt_tick_increase();
+
+    /* leave interrupt */
+    rt_interrupt_leave();
+
+    TRACE("isr: systick leave!\n");
+    return 0;
+}
+