243 lines
5.6 KiB
C
243 lines
5.6 KiB
C
#include "lwip/opt.h"
|
|
#include "lwip/sys.h"
|
|
#include "arch/sys_arch.h"
|
|
|
|
#include <string.h>
|
|
|
|
static char pcQueueMemoryPool[MAX_QUEUES * sizeof(TQ_DESCR)];
|
|
static OS_MEM *pQueueMem;
|
|
|
|
mem_ptr_t lwip_null = 0xffffffff;
|
|
void *pvNullPointer = &lwip_null;
|
|
|
|
static OS_STK task_tcpip_stk[TCPIP_THREAD_STACKSIZE];
|
|
|
|
/* 初始化sys_arch层 */
|
|
void sys_init(void)
|
|
{
|
|
uint8_t ucErr;
|
|
pQueueMem = OSMemCreate((void*)pcQueueMemoryPool, MAX_QUEUES, sizeof(TQ_DESCR), &ucErr);
|
|
}
|
|
|
|
/* 建立并返回一个新的信号量。参数count指定信号量的初始状态 */
|
|
err_t sys_sem_new(sys_sem_t *sem, u8_t count)
|
|
{
|
|
uint8_t err;
|
|
*sem = OSSemCreate((u16_t)count);
|
|
if (*sem == ((sys_sem_t)0)) {
|
|
return ERR_MEM;
|
|
}
|
|
OSEventNameSet(*sem,(uint8_t *)"LWIP Sem",&err);
|
|
return ERR_OK;
|
|
}
|
|
|
|
/* 发送一个信号 */
|
|
void sys_sem_signal(sys_sem_t *sem)
|
|
{
|
|
OSSemPost(*sem);
|
|
}
|
|
|
|
/* 等待指定的信号并阻塞线程 */
|
|
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
|
|
{
|
|
uint8_t ucErr;
|
|
uint32_t ucos_timeout, timeout_new;
|
|
if( timeout!=0)
|
|
{
|
|
ucos_timeout = (timeout * OS_TICKS_PER_SEC) / 1000;
|
|
if(ucos_timeout < 1)
|
|
ucos_timeout = 1;
|
|
}else ucos_timeout = 0;
|
|
timeout = OSTimeGet();
|
|
OSSemPend (*sem,(u16_t)ucos_timeout, (u8_t *)&ucErr);
|
|
if(ucErr == OS_ERR_TIMEOUT)timeout=SYS_ARCH_TIMEOUT;
|
|
else
|
|
{
|
|
timeout_new = OSTimeGet();
|
|
if (timeout_new>=timeout) timeout_new = timeout_new - timeout;
|
|
else timeout_new = 0xffffffff - timeout + timeout_new;
|
|
timeout = (timeout_new*1000/OS_TICKS_PER_SEC + 1);
|
|
}
|
|
return timeout;
|
|
}
|
|
|
|
/* 释放信号量 */
|
|
void sys_sem_free(sys_sem_t *sem)
|
|
{
|
|
uint8_t Err;
|
|
OSSemDel(*sem, OS_DEL_ALWAYS, &Err);
|
|
*sem = NULL;
|
|
}
|
|
|
|
#ifndef sys_sem_valid
|
|
/* 判定信号量是否有效 */
|
|
int sys_sem_valid(sys_sem_t *sem)
|
|
{
|
|
OS_SEM_DATA sem_data;
|
|
return (OSSemQuery (*sem,&sem_data) == OS_ERR_NONE )? 1:0;
|
|
}
|
|
#endif
|
|
|
|
#ifndef sys_sem_set_invalid
|
|
/* 设置信号量为无效 */
|
|
void sys_sem_set_invalid(sys_sem_t *sem)
|
|
{
|
|
*sem = ((sys_sem_t)0);
|
|
}
|
|
#endif
|
|
|
|
/* 建立一个空的邮箱 */
|
|
err_t sys_mbox_new(sys_mbox_t *mbox, int size)
|
|
{
|
|
uint8_t Err;
|
|
if(size > MAX_QUEUE_ENTRIES) {
|
|
size = MAX_QUEUE_ENTRIES;
|
|
}
|
|
*mbox = (sys_mbox_t)OSMemGet(pQueueMem, &Err);
|
|
if( Err == OS_ERR_NONE) {
|
|
(*mbox)->pQ = OSQCreate(&((*mbox)->pvQEntries[0]), size);
|
|
if ((*mbox)->pQ != ((OS_EVENT *)0)) {
|
|
return ERR_OK;
|
|
} else {
|
|
OSMemPut(pQueueMem, mbox);
|
|
}
|
|
}
|
|
return ERR_MEM;
|
|
|
|
}
|
|
|
|
/* 投递消息到指定邮箱 */
|
|
void sys_mbox_post(sys_mbox_t *mbox, void *msg)
|
|
{
|
|
if(!msg) {
|
|
msg = (void*)&pvNullPointer;
|
|
}
|
|
while (OS_ERR_NONE != OSQPost((*mbox)->pQ, msg));
|
|
}
|
|
|
|
err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
|
|
{
|
|
INT8U err;
|
|
if(!msg) {
|
|
msg = (void*)&pvNullPointer;
|
|
}
|
|
err = OSQPost((*mbox)->pQ, msg);
|
|
if (err == OS_ERR_NONE) {
|
|
return ERR_OK;
|
|
}
|
|
return ERR_MEM;
|
|
}
|
|
|
|
/* 阻塞线程直至邮箱至少收到一条信息 */
|
|
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
|
|
{
|
|
u8_t ucErr;
|
|
u32_t ucos_timeout,timeout_new;
|
|
void *temp;
|
|
sys_mbox_t m_box=*mbox;
|
|
if(timeout!=0)
|
|
{
|
|
ucos_timeout=(timeout*OS_TICKS_PER_SEC)/1000;
|
|
if(ucos_timeout<1)ucos_timeout=1;
|
|
}else ucos_timeout = 0;
|
|
timeout = OSTimeGet();
|
|
temp=OSQPend(m_box->pQ,(u16_t)ucos_timeout,&ucErr);
|
|
if(msg!=NULL)
|
|
{
|
|
if(temp==(void*)&pvNullPointer)*msg = NULL;
|
|
else *msg=temp;
|
|
}
|
|
if(ucErr==OS_ERR_TIMEOUT)timeout=SYS_ARCH_TIMEOUT;
|
|
else
|
|
{
|
|
LWIP_ASSERT("OSQPend ",ucErr==OS_ERR_NONE);
|
|
timeout_new=OSTimeGet();
|
|
if (timeout_new>timeout) timeout_new = timeout_new - timeout;
|
|
else timeout_new = 0xffffffff - timeout + timeout_new;
|
|
timeout=timeout_new*1000/OS_TICKS_PER_SEC + 1;
|
|
}
|
|
return timeout;
|
|
}
|
|
|
|
#ifndef sys_arch_mbox_tryfetch
|
|
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
|
|
{
|
|
return sys_arch_mbox_fetch(mbox,msg,1);
|
|
}
|
|
#endif
|
|
|
|
/* 释放一个邮箱 */
|
|
void sys_mbox_free(sys_mbox_t *mbox)
|
|
{
|
|
u8_t Err;
|
|
OSQFlush((*mbox)->pQ);
|
|
OSQDel((*mbox)->pQ, OS_DEL_ALWAYS, &Err);
|
|
OSMemPut(pQueueMem, *mbox);
|
|
*mbox = (sys_mbox_t)0;
|
|
}
|
|
|
|
#ifndef sys_mbox_valid
|
|
/* 判定邮箱是否有效 */
|
|
int sys_mbox_valid(sys_mbox_t *mbox)
|
|
{
|
|
sys_mbox_t m_box=*mbox;
|
|
u8_t ucErr;
|
|
int ret;
|
|
OS_Q_DATA q_data;
|
|
memset(&q_data,0,sizeof(OS_Q_DATA));
|
|
ucErr = OSQQuery (m_box->pQ,&q_data);
|
|
ret = (ucErr < 2 && (q_data.OSNMsgs < q_data.OSQSize)) ? 1 : 0;
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
#ifndef sys_mbox_set_invalid
|
|
/* 设置邮箱为无效 */
|
|
void sys_mbox_set_invalid(sys_mbox_t *mbox)
|
|
{
|
|
*mbox = ((sys_mbox_t)0);
|
|
}
|
|
#endif
|
|
|
|
sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg,
|
|
int stacksize, int prio)
|
|
{
|
|
CPU_SR_ALLOC();
|
|
arg = arg;
|
|
stacksize = stacksize;
|
|
if (0 == strcmp(name, TCPIP_THREAD_NAME)) {
|
|
OS_ENTER_CRITICAL();
|
|
OSTaskCreateExt((void (*)(void *)) thread, /* Create the start task */
|
|
(void *) 0,
|
|
(OS_STK *)&task_tcpip_stk[TCPIP_THREAD_STACKSIZE - 1],
|
|
(INT8U ) prio,
|
|
(INT16U ) prio,
|
|
(OS_STK *)&task_tcpip_stk[0],
|
|
(INT32U ) TCPIP_THREAD_STACKSIZE,
|
|
(void *) 0,
|
|
(INT16U )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR));
|
|
OS_EXIT_CRITICAL();
|
|
} else {
|
|
prio = 0;
|
|
}
|
|
return prio;
|
|
}
|
|
|
|
u32_t sys_now(void)
|
|
{
|
|
u32_t ucos_time, lwip_time;
|
|
ucos_time=OSTimeGet();
|
|
lwip_time=(ucos_time*1000/OS_TICKS_PER_SEC+1);
|
|
return lwip_time;
|
|
}
|
|
|
|
sys_prot_t sys_arch_protect(void)
|
|
{
|
|
return OS_CPU_SR_Save();
|
|
}
|
|
|
|
void sys_arch_unprotect(sys_prot_t pval)
|
|
{
|
|
OS_CPU_SR_Restore(pval);
|
|
}
|