libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

Merge pull request #19 from prife/simmerge 

merge simulator for linux to master branch
This commit is contained in:
Bernard Xiong 2013-01-22 04:10:04 -08:00
parent 8bbd54ddf6 832bbb9fe2
commit ead6922231
11 changed files with 763 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
bsp/simulator/SConstruct Normal file → Executable file
View File

@ -18,38 +18,44 @@ else:
sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')] sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')]
from building import * from building import *
TARGET = 'rtthread-win32.' + rtconfig.TARGET_EXT
env = Environment() env = Environment()
Export('RTT_ROOT') Export('RTT_ROOT')
Export('rtconfig') Export('rtconfig')
libs = Split(''' if rtconfig.PLATFORM == 'cl':
winmm TARGET = 'rtthread-win32.' + rtconfig.TARGET_EXT
gdi32
winspool libs = Split('''
comdlg32 winmm
advapi32 gdi32
shell32 winspool
ole32 comdlg32
oleaut32 advapi32
uuid shell32
odbc32 ole32
odbccp32 oleaut32
''') uuid
definitions = Split(''' odbc32
WIN32 odbccp32
_DEBUG ''')
_CONSOLE definitions = Split('''
MSVC WIN32
_TIME_T_DEFINED _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 # prepare building environment

4
bsp/simulator/applications/SConscript
View File

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

24
bsp/simulator/applications/application.c Normal file → Executable file
View File

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

37
bsp/simulator/drivers/board.c Normal file → Executable file
View File

@ -16,7 +16,6 @@
#include <rtthread.h> #include <rtthread.h>
#include "board.h" #include "board.h"
#include <stdlib.h> #include <stdlib.h>
#include <windows.h>
/** /**
* @addtogroup simulator on win32 * @addtogroup simulator on win32
@ -30,29 +29,56 @@ rt_uint8_t *rt_hw_sram_init(void)
if (heap == RT_NULL) if (heap == RT_NULL)
{ {
rt_kprintf("there is no memory in pc."); rt_kprintf("there is no memory in pc.");
#ifdef _WIN32
_exit(1); _exit(1);
#else
exit(1);
#endif
} }
return heap; return heap;
} }
#ifdef _WIN32
#include <windows.h>
#endif
void rt_hw_win32_low_cpu(void) void rt_hw_win32_low_cpu(void)
{ {
#ifdef _WIN32
/* in windows */
Sleep(1000); Sleep(1000);
#else
/* in linux */
sleep(1);
#endif
} }
#if defined(RT_USING_FINSH) #ifdef _WIN32
#ifndef _CRT_TERMINATE_DEFINED #ifndef _CRT_TERMINATE_DEFINED
#define _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 __declspec(noreturn) void __cdecl _exit(__in int _Code); _CRTIMP __declspec(noreturn) void __cdecl _exit(__in int _Code);
_CRTIMP void __cdecl abort(void); _CRTIMP void __cdecl abort(void);
#endif #endif
#endif
#if defined(RT_USING_FINSH)
#include <finsh.h> #include <finsh.h>
void rt_hw_exit(void) void rt_hw_exit(void)
{ {
rt_kprintf("RT-Thread, bye\n"); 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); exit(0);
} }
FINSH_FUNCTION_EXPORT_ALIAS(rt_hw_exit, exit, exit rt - thread); FINSH_FUNCTION_EXPORT_ALIAS(rt_hw_exit, exit, exit rt - thread);
@ -66,8 +92,11 @@ void rt_hw_board_init()
/* init system memory */ /* init system memory */
heap = rt_hw_sram_init(); heap = rt_hw_sram_init();
#if defined(RT_USING_CONSOLE) //#if defined(RT_USING_USART)
rt_hw_usart_init(); rt_hw_usart_init();
//#endif
#if defined(RT_USING_CONSOLE)
rt_hw_serial_init(); rt_hw_serial_init();
rt_console_set_device(RT_CONSOLE_DEVICE_NAME); rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
#endif #endif

4
bsp/simulator/drivers/sd_sim.c Normal file → Executable file
View File

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

28
bsp/simulator/drivers/sdl_fb.c Normal file → Executable file
View File

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

9
bsp/simulator/drivers/serial.c Normal file → Executable file
View File

@ -13,8 +13,12 @@
#include "serial.h" #include "serial.h"
#include <stdio.h> #include <stdio.h>
struct rt_device serial_device; 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; 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 #if _DEBUG_SERIAL==1
printf("in rt_serial_write()\n"); printf("in rt_serial_write()\n");
#endif #endif
#if 0
if (fp == NULL) if (fp == NULL)
fp = fopen("log.txt", "wb+"); fp = fopen("log.txt", "wb+");
if (fp != NULL) if (fp != NULL)
fwrite(buffer, size, 1, fp); fwrite(buffer, size, 1, fp);
#endif
printf("%s", (char *)buffer); printf("%s", (char *)buffer);
fflush(stdout);
return size; return size;
} }

68
bsp/simulator/drivers/usart_sim.c Normal file → Executable file
View File

@ -1,15 +1,19 @@
#include <rthw.h> #include <rthw.h>
#include <rtthread.h> #include <rtthread.h>
#ifdef _WIN32
#include <windows.h> #include <windows.h>
#include <mmsystem.h> #include <mmsystem.h>
#include <stdio.h>
#include <conio.h> #include <conio.h>
#endif
#include <stdio.h>
#include "serial.h" #include "serial.h"
struct serial_int_rx serial_rx; struct serial_int_rx serial_rx;
extern struct rt_device serial_device; extern struct rt_device serial_device;
#ifdef _WIN32
/* /*
* Handler for OSKey Thread * Handler for OSKey Thread
*/ */
@ -19,7 +23,6 @@ static DWORD OSKey_ThreadID;
static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam); static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam);
void rt_hw_usart_init(void) void rt_hw_usart_init(void)
{ {
/* /*
* create serial thread that receive key input from keyboard * create serial thread that receive key input from keyboard
*/ */
@ -46,9 +49,31 @@ void rt_hw_usart_init(void)
* Start OS get key Thread * Start OS get key Thread
*/ */
ResumeThread(OSKey_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 * ·½Ïò¼ü(¡û)£º 0xe04b
* ·½Ïò¼ü(¡ü)£º 0xe048 * ·½Ïò¼ü(¡ü)£º 0xe048
@ -100,15 +125,48 @@ static int savekey(unsigned char key)
} }
return 0; return 0;
} }
#ifdef _WIN32
static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam) 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; 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 (void)lpParam; //prevent compiler warnings
for (;;) for (;;)
{ {
key = getch(); key = getch();
#ifdef _WIN32
if (key == 0xE0) if (key == 0xE0)
{ {
key = getch(); key = getch();
@ -128,7 +186,7 @@ static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam)
continue; continue;
} }
#endif
savekey(key); savekey(key);
} }
} /*** ThreadforKeyGet ***/ } /*** ThreadforKeyGet ***/

16
bsp/simulator/rtconfig.h Normal file → Executable file
View File

@ -2,15 +2,15 @@
#ifndef __RTTHREAD_CFG_H__ #ifndef __RTTHREAD_CFG_H__
#define __RTTHREAD_CFG_H__ #define __RTTHREAD_CFG_H__
#define RT_HEAP_SIZE (1024*1024*2)
#if defined(_MSC_VER)
/* SECTION: port for visual studio */ /* SECTION: port for visual studio */
#ifdef _MSC_VER
#undef RT_USING_NEWLIB #undef RT_USING_NEWLIB
#undef RT_USING_MINILIBC #undef RT_USING_MINILIBC
#define NORESOURCE //RT_VESRION in winuser.h #define NORESOURCE //RT_VESRION in winuser.h
#define _CRT_ERRNO_DEFINED //errno macro redefinition #define _CRT_ERRNO_DEFINED //errno macro redefinition
#define RT_HEAP_SIZE (1024*1024*2)
/* disable some warning in MSC */ /* disable some warning in MSC */
#pragma warning(disable:4273) /* to ignore: warning C4273: inconsistent dll linkage */ #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 *' */ #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: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: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 */ #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 #endif
/* SECTION: basic kernel options */ /* SECTION: basic kernel options */
@ -31,11 +34,12 @@
#define RT_THREAD_PRIORITY_MAX 32 #define RT_THREAD_PRIORITY_MAX 32
/* Tick per Second */ /* Tick per Second */
#define RT_TICK_PER_SECOND 1000 #define RT_TICK_PER_SECOND 100
/* SECTION: RT_DEBUG */ /* SECTION: RT_DEBUG */
/* Thread Debug */ /* Thread Debug */
#define RT_DEBUG #define RT_DEBUG
//#define RT_DEBUG_SCHEDULER 1
#define RT_THREAD_DEBUG #define RT_THREAD_DEBUG
#define RT_USING_OVERFLOW_CHECK #define RT_USING_OVERFLOW_CHECK
@ -129,11 +133,11 @@
/* #define RT_UFFS_USE_CHECK_MARK_FUNCITON */ /* #define RT_UFFS_USE_CHECK_MARK_FUNCITON */
/* DFS: JFFS2 nor flash file system options */ /* 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 */ /* DFS: windows share directory mounted to rt-thread/dfs */
/* only used in bsp/simulator */ /* only used in bsp/simulator */
#define RT_USING_DFS_WINSHAREDIR //#define RT_USING_DFS_WINSHAREDIR
/* the max number of mounted file system */ /* the max number of mounted file system */
#define DFS_FILESYSTEMS_MAX 4 #define DFS_FILESYSTEMS_MAX 4

15
bsp/simulator/rtconfig.py Normal file → Executable file
View File

@ -1,7 +1,9 @@
# toolchains options # toolchains options
ARCH='sim' ARCH='sim'
CPU='win32' #CPU='posix' #CPU='win32'
CROSS_TOOL='msvc' #win32 #CPU='posix'
CPU='posix'
CROSS_TOOL='gcc' #msvc # gcc
# lcd panel options # lcd panel options
# 'FMT0371','ILI932X', 'SSD1289' # 'FMT0371','ILI932X', 'SSD1289'
@ -33,16 +35,19 @@ if PLATFORM == 'gcc':
OBJCPY = PREFIX + 'objcopy' OBJCPY = PREFIX + 'objcopy'
DEVICE = ' -ffunction-sections -fdata-sections' DEVICE = ' -ffunction-sections -fdata-sections'
CFLAGS = DEVICE DEVICE = ' '
CFLAGS = DEVICE + ' -I/usr/include -w -D_REENTRANT'
AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp' 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,-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 = '' CPATH = ''
LPATH = '' LPATH = ''
if BUILD == 'debug': if BUILD == 'debug':
CFLAGS += ' -O0 -gdwarf-2' CFLAGS += ' -g -O0 -gdwarf-2'
AFLAGS += ' -gdwarf-2' AFLAGS += ' -gdwarf-2'
else: else:
CFLAGS += ' -O2' CFLAGS += ' -O2'

566
libcpu/sim/posix/cpu_port.c Normal file
View File

@ -0,0 +1,566 @@
/*
* 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;
}