578 lines
22 KiB
C
578 lines
22 KiB
C
/*
|
||
* Copyright (c) 2001-2003 Swedish Institute of Computer Science.
|
||
* All rights reserved.
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without modification,
|
||
* are permitted provided that the following conditions are met:
|
||
*
|
||
* 1. Redistributions of source code must retain the above copyright notice,
|
||
* this list of conditions and the following disclaimer.
|
||
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
||
* this list of conditions and the following disclaimer in the documentation
|
||
* and/or other materials provided with the distribution.
|
||
* 3. The name of the author may not be used to endorse or promote products
|
||
* derived from this software without specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
||
* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
||
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
||
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
|
||
* OF SUCH DAMAGE. * * This file is part of the lwIP TCP/IP stack.
|
||
*
|
||
* Author: Adam Dunkels
|
||
*
|
||
*/
|
||
/* lwIP includes. */
|
||
#include "lwip/debug.h"
|
||
#include "lwip/def.h"
|
||
#include "lwip/sys.h"
|
||
#include "lwip/mem.h"
|
||
#include "lpc_arch.h"
|
||
#include "app_cfg.h"
|
||
#include
|
||
#if NO_SYS==0
|
||
/* ------------------------ System architecture includes ----------------------------- */
|
||
#include "arch/sys_arch.h"
|
||
/* ------------------------ lwIP includes --------------------------------- */
|
||
#include "lwip/opt.h"
|
||
#include "lwip/stats.h"
|
||
/*----------------------------------------------------------------------------*/
|
||
/* DEFINITIONS */
|
||
/*----------------------------------------------------------------------------*/
|
||
//#define OS_CFG_TICK_RATE_HZ 1000
|
||
/*----------------------------------------------------------------------------*/
|
||
/* VARIABLES */
|
||
/*----------------------------------------------------------------------------*/
|
||
//定义lwip线程所需要的资源
|
||
static OS_MEM StackMem;
|
||
const void * const pvNullPointer = (mem_ptr_t*)0xffffffff;
|
||
__align(4) CPU_STK LwIP_Task_Stk[LWIP_TASK_MAX*LWIP_STK_SIZE];
|
||
__align(4) CPU_INT08U LwIP_task_priopity_stask[LWIP_TASK_MAX];
|
||
OS_TCB LwIP_task_TCB[LWIP_TASK_MAX];
|
||
/*---------------------------------------------------------------------------
|
||
*
|
||
* prototypes dealing with mailbox
|
||
*---------------------------------------------------------------------------*/
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_mbox_new ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Creates a new mailbox
|
||
* Inputs:
|
||
* sys_mbox_t *pxMailBox -- Handle to new mailbox
|
||
* s32_t size -- Size of elements in the mailbox
|
||
* Outputs:
|
||
* err_t -- lwip error type
|
||
*---------------------------------------------------------------------------*/
|
||
err_t sys_mbox_new( sys_mbox_t *pxMailBox, s32_t size )
|
||
{
|
||
OS_ERR ucErr;
|
||
|
||
OSQCreate(pxMailBox,"LWIP queue", size, &ucErr); //debugging interface need to defined by user
|
||
if (ucErr == OS_ERR_NONE)
|
||
{
|
||
return ERR_OK;
|
||
}
|
||
return ERR_MEM;
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_mbox_free ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description: * Deallocates a mailbox. Flush message queue and the deallocate it
|
||
* different from freertos
|
||
* Inputs:
|
||
* sys_mbox_t *pxMailBox -- Handle of mailbox
|
||
*---------------------------------------------------------------------------*/
|
||
void sys_mbox_free( sys_mbox_t *pxMailBox )
|
||
{
|
||
OS_ERR ucErr;
|
||
|
||
//LWIP_ASSERT( "sys_mbox_free ", pxMailBox != SYS_MBOX_NULL ); //清空消息队列
|
||
OSQFlush(pxMailBox,& ucErr); OSQDel(pxMailBox, OS_OPT_DEL_ALWAYS, &ucErr);
|
||
//LWIP_ASSERT( "OSQDel ", ucErr == OS_ERR_NONE );
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_mbox_post ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Post the "pxMessageToPost" to the mailbox.
|
||
* Inputs:
|
||
* sys_mbox_t pxMailBox -- Handle of mailbox
|
||
* void *pxMessageToPost -- Pointer to data to post
|
||
*---------------------------------------------------------------------------*/
|
||
void sys_mbox_post( sys_mbox_t *pxMailBox, void *pxMessageToPost )
|
||
{
|
||
OS_ERR ucErr;
|
||
CPU_INT08U i=0; //消息指针为空，则指向一个默认的消息
|
||
|
||
if( pxMessageToPost == NULL )
|
||
pxMessageToPost = (void*)&pvNullPointer; /* try 10 times */
|
||
|
||
while(i<10){
|
||
OSQPost(pxMailBox, pxMessageToPost,sizeof(pxMessageToPost),OS_OPT_POST_ALL,&ucErr);
|
||
if(ucErr == OS_ERR_NONE) break;
|
||
i++;
|
||
OSTimeDly(5,OS_OPT_TIME_DLY,&ucErr);
|
||
}
|
||
//LWIP_ASSERT( "sys_mbox_post error!\n", i !=10 );
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_mbox_trypost ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Try to post the "msg" to the mailbox. Returns immediately with
|
||
* error if cannot.
|
||
* Inputs:
|
||
* sys_mbox_t pxMailBox -- Handle of mailbox
|
||
* void *pxMessageToPost -- Pointer to data to post
|
||
* Outputs:
|
||
* err_t -- ERR_OK if message posted, else ERR_MEM
|
||
* if not.
|
||
*---------------------------------------------------------------------------*/
|
||
err_t sys_mbox_trypost( sys_mbox_t *pxMailBox, void *pxMessageToPost )
|
||
{
|
||
OS_ERR ucErr;
|
||
|
||
if(pxMessageToPost == NULL ) pxMessageToPost = (void*)&pvNullPointer;
|
||
OSQPost(pxMailBox, pxMessageToPost,sizeof(pxMessageToPost),OS_OPT_POST_ALL,&ucErr);
|
||
if(ucErr != OS_ERR_NONE){
|
||
return ERR_MEM;
|
||
}
|
||
return ERR_OK;
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_arch_mbox_fetch ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Blocks the thread until a message arrives in the mailbox, but does
|
||
* not block the thread longer than "timeout" milliseconds (similar to
|
||
* the sys_arch_sem_wait() function). The "msg" argument is a result
|
||
* parameter that is set by the function (i.e., by doing "*msg =
|
||
* ptr"). The "msg" parameter maybe NULL to indicate that the message
|
||
* should be dropped.
|
||
*
|
||
* The return values are the same as for the sys_arch_sem_wait() function:
|
||
* Number of milliseconds spent waiting or SYS_ARCH_TIMEOUT if there was a
|
||
* timeout.
|
||
*
|
||
* Note that a function with a similar name, sys_mbox_fetch(), is
|
||
* implemented by lwIP.
|
||
* Inputs:
|
||
* sys_mbox_t pxMailBox -- Handle of mailbox
|
||
* void **ppvBuffer -- Pointer to pointer to msg received
|
||
* u32_t ulTimeOut -- Number of milliseconds until timeout
|
||
* Outputs:
|
||
* u32_t -- SYS_ARCH_TIMEOUT if timeout, else number
|
||
* of milliseconds until received.
|
||
*---------------------------------------------------------------------------*/
|
||
u32_t sys_arch_mbox_fetch( sys_mbox_t *pxMailBox, void **ppvBuffer, u32_t ulTimeOut )
|
||
{
|
||
OS_ERR ucErr;
|
||
OS_MSG_SIZE msg_size;
|
||
CPU_TS ucos_timeout;
|
||
CPU_TS in_timeout = ulTimeOut/LWIP_ARCH_TICK_PER_MS;
|
||
|
||
if(ulTimeOut && in_timeout == 0)
|
||
in_timeout = 1;
|
||
ucos_timeout=0;
|
||
*ppvBuffer = OSQPend (pxMailBox,in_timeout,OS_OPT_PEND_BLOCKING,&msg_size, 0,&ucErr);
|
||
if ( ucErr == OS_ERR_TIMEOUT )
|
||
ucos_timeout = SYS_ARCH_TIMEOUT;
|
||
|
||
return ucos_timeout;
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_arch_mbox_tryfetch usosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Similar to sys_arch_mbox_fetch, but if message is not ready
|
||
* immediately, we'll return with SYS_MBOX_EMPTY. On success, 0 is
|
||
* returned.
|
||
* Inputs:
|
||
* sys_mbox_t mbox -- Handle of mailbox
|
||
* void **msg -- Pointer to pointer to msg received
|
||
* Outputs:
|
||
* u32_t -- SYS_MBOX_EMPTY if no messages. Otherwise,
|
||
* return ERR_OK.
|
||
* complementary:
|
||
* ucos中暂时没有相应的实现机制，暂时使用sys_arch_mbox_fetch实现
|
||
*---------------------------------------------------------------------------*/
|
||
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_mbox_valid usosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Check if an mbox is valid/allocated
|
||
* if success return 1
|
||
* Inputs:
|
||
* sys_mbox_t *pxMailBox -- Handle of mailbox
|
||
* Outputs: * s32_t -- 1 if valid. Otherwise return 0
|
||
*---------------------------------------------------------------------------*/
|
||
s32_t sys_mbox_valid(sys_mbox_t *pxMailBox)
|
||
{
|
||
if(pxMailBox->NamePtr)
|
||
return (strcmp(pxMailBox->NamePtr,"?Q"))? 1:0;
|
||
else
|
||
return 0;
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_mbox_invalid usosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Set an mbox invalid so that sys_mbox_valid returns 0
|
||
* Inputs:
|
||
* sys_mbox_t *pxMailBox -- Handle of mailbox
|
||
*---------------------------------------------------------------------------*/
|
||
void sys_mbox_set_invalid(sys_mbox_t *pxMailBox)
|
||
{
|
||
if(sys_mbox_valid(pxMailBox))
|
||
sys_mbox_free(pxMailBox);
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* prototypes dealing with semaphore
|
||
*---------------------------------------------------------------------------*/
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_sem_new ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Creates and returns a new semaphore. The "ucCount" argument specifies
|
||
* the initial state of the semaphore.
|
||
* NOTE: Currently this routine only creates counts of 1 or 0 * Inputs:
|
||
* sys_mbox_t mbox -- Handle of mailbox
|
||
* u8_t ucCount -- Initial ucCount of semaphore (1 or 0)
|
||
* Outputs:
|
||
* sys_sem_t -- Created semaphore or 0 if could not create.
|
||
*---------------------------------------------------------------------------*/
|
||
err_t sys_sem_new( sys_sem_t *pxSemaphore, u8_t ucCount )
|
||
{
|
||
OS_ERR ucErr;
|
||
|
||
OSSemCreate (pxSemaphore,"LWIP Sem",ucCount,&ucErr);
|
||
if(ucErr != OS_ERR_NONE ){
|
||
//LWIP_ASSERT("OSSemCreate ",ucErr == OS_ERR_NONE );
|
||
return ERR_MEM;
|
||
}
|
||
return ERR_OK;
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_arch_sem_wait
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Blocks the thread while waiting for the semaphore to be
|
||
* signaled. If the "timeout" argument is non-zero, the thread should
|
||
* only be blocked for the specified time (measured in * milliseconds).
|
||
*
|
||
* If the timeout argument is non-zero, the return value is the number of
|
||
* milliseconds spent waiting for the semaphore to be signaled. If the
|
||
* semaphore wasn't signaled within the specified time, the return value is
|
||
* SYS_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore
|
||
* (i.e., it was already signaled), the function may return zero.
|
||
*
|
||
* Notice that lwIP implements a function with a similar name,
|
||
* sys_sem_wait(), that uses the sys_arch_sem_wait() function.
|
||
* Inputs:
|
||
* sys_sem_t sem -- Semaphore to wait on
|
||
* u32_t timeout -- Number of milliseconds until timeout
|
||
* Outputs:
|
||
* u32_t -- Time elapsed or SYS_ARCH_TIMEOUT.
|
||
*---------------------------------------------------------------------------*/
|
||
u32_t sys_arch_sem_wait( sys_sem_t *pxSemaphore, u32_t ulTimeout )
|
||
{
|
||
OS_ERR ucErr;
|
||
CPU_TS ucos_timeout;
|
||
CPU_TS in_timeout = ulTimeout/LWIP_ARCH_TICK_PER_MS;
|
||
|
||
if(ulTimeout && in_timeout == 0)
|
||
in_timeout = 1;
|
||
//OSSemPend (pxSemaphore,in_timeout,OS_OPT_PEND_BLOCKING,0,&ucErr);
|
||
//OSSemPend (pxSemaphore,ulTimeout,OS_OPT_PEND_BLOCKING,0,&ucErr);
|
||
OSSemPend (pxSemaphore,0,OS_OPT_PEND_BLOCKING,0,&ucErr); /* only when timeout! */
|
||
|
||
if(ucErr == OS_ERR_TIMEOUT)
|
||
ucos_timeout = SYS_ARCH_TIMEOUT;
|
||
|
||
return ucos_timeout;
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_mutex_new ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Creates and returns a new Mutex.
|
||
* Inputs:
|
||
* sys_mutex_t pxMutex -- Handle of mailbox
|
||
* Outputs:
|
||
* sys_mutex_t -- Created semaphore or 0 if could not create.
|
||
*---------------------------------------------------------------------------*/
|
||
err_t sys_mutex_new( sys_mutex_t *pxMutex )
|
||
{
|
||
OS_ERR ucErr;
|
||
OSMutexCreate(pxMutex,"LWIP Mutex",&ucErr);
|
||
if(ucErr != OS_ERR_NONE ){ //LWIP_ASSERT("OSMutexCreate ",ucErr == OS_ERR_NONE );
|
||
return ERR_MEM;
|
||
}
|
||
return ERR_OK;
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_mutex_lock ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Lock a mutex
|
||
* Inputs:
|
||
* sys_mutex_t pxMutex -- the mutex to lock
|
||
*---------------------------------------------------------------------------*/
|
||
void sys_mutex_lock( sys_mutex_t *pxMutex )
|
||
{
|
||
OS_ERR ucERR;
|
||
OSMutexPend(pxMutex,0,OS_OPT_POST_ALL,NULL,&ucERR);
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_mutex_unlock ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* unLock a mutex
|
||
* Inputs:
|
||
* sys_mutex_t pxMutex -- the mutex to unlock
|
||
*---------------------------------------------------------------------------*/
|
||
void sys_mutex_unlock(sys_mutex_t *pxMutex )
|
||
{
|
||
OS_ERR ucERR;
|
||
OSMutexPost(pxMutex,OS_OPT_POST_NONE,&ucERR);
|
||
}
|
||
/*
|
||
* Delete a semaphore
|
||
* @param pxMutex the mutex to delete
|
||
*/
|
||
/*
|
||
void sys_mutex_free( sys_mutex_t *pxMutex )
|
||
{
|
||
OS_ERR ucERR;
|
||
OSMutexDel(pxMutex,OS_OPT_DEL_ALWAYS,&ucERR);
|
||
}
|
||
*/
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_sem_signal ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Signals (releases) a semaphore
|
||
* Inputs:
|
||
* sys_sem_t pxSemaphore -- Semaphore to signal
|
||
*---------------------------------------------------------------------------*/
|
||
void sys_sem_signal( sys_sem_t *pxSemaphore )
|
||
{
|
||
OS_ERR ucErr;
|
||
OSSemPost(pxSemaphore,OS_OPT_POST_ALL,&ucErr);
|
||
//LWIP_ASSERT("OSSemPost ",ucErr == OS_ERR_NONE );
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_sem_free ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Deallocates a semaphore
|
||
* Inputs:
|
||
* sys_sem_t pxSemaphore -- Semaphore to free
|
||
*---------------------------------------------------------------------------*/
|
||
void sys_sem_free( sys_sem_t *pxSemaphore )
|
||
{
|
||
OS_ERR ucErr;
|
||
OSSemDel(pxSemaphore, OS_OPT_DEL_ALWAYS, &ucErr );
|
||
//LWIP_ASSERT( "OSSemDel ", ucErr == OS_ERR_NONE );
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_sem_valid usosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Check if an mbox is valid/allocated
|
||
* if success return 1
|
||
* Inputs:
|
||
* sys_mbox_t *pxSemaphore -- Handle of mailbox
|
||
* Outputs:
|
||
* s32_t -- 1 if valid. Otherwise return 0
|
||
*---------------------------------------------------------------------------*/
|
||
s32_t sys_sem_valid(sys_sem_t *pxSemaphore)
|
||
{
|
||
if(pxSemaphore->NamePtr)
|
||
return (strcmp(pxSemaphore->NamePtr,"?SEM"))? 1:0;
|
||
else
|
||
return 0;
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_sem_set_invalid usosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Set an mbox invalid so that sys_mbox_valid returns 0
|
||
* Inputs:
|
||
* sys_mbox_t *pxSemaphore -- Handle of mailbox
|
||
*---------------------------------------------------------------------------*/
|
||
void sys_sem_set_invalid(sys_sem_t *pxSemaphore)
|
||
{
|
||
if(sys_sem_valid(pxSemaphore)) sys_sem_free(pxSemaphore);
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_init
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Initialize sys arch
|
||
*---------------------------------------------------------------------------*/
|
||
void sys_init(void)
|
||
{
|
||
OS_ERR ucErr;
|
||
memset(LwIP_task_priopity_stask,0,sizeof(LwIP_task_priopity_stask));
|
||
/* init mem used by sys_mbox_t, use ucosIII functions */
|
||
OSMemCreate(&StackMem, "LWIP TASK STK", (void*)LwIP_Task_Stk,LWIP_TASK_MAX, LWIP_STK_SIZE*sizeof(CPU_STK), &ucErr);
|
||
//LWIP_ASSERT( "sys_init: failed OSMemCreate STK", ucErr == OS_ERR_NONE );
|
||
}
|
||
|
||
/*暂未使能ucosiii计时功能
|
||
u32_t sys_now(void)
|
||
{
|
||
return xTaskGetTickCount();
|
||
}
|
||
*/
|
||
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_thread_new
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* Starts a new thread with priority "prio" that will begin its
|
||
* execution in the function "thread()". The "arg" argument will be
|
||
* passed as an argument to the thread() function. The id of the new
|
||
* thread is returned. Both the id and the priority are system
|
||
* dependent.
|
||
* Inputs:
|
||
* char *name -- Name of thread
|
||
* void (* thread)(void *arg) -- Pointer to function to run.
|
||
* void *arg -- Argument passed into function
|
||
* int stacksize -- Required stack amount in bytes
|
||
* int prio -- Thread priority
|
||
* Outputs:
|
||
* sys_thread_t -- Pointer to per-thread timeouts.
|
||
*---------------------------------------------------------------------------*/
|
||
sys_thread_t sys_thread_new( const char *name, void( *thread )( void *pvParameters ), void *arg, int stacksize, int prio )
|
||
{
|
||
CPU_INT08U ubPrio = LWIP_TASK_START_PRIO;
|
||
CPU_INT08U tsk_prio;
|
||
CPU_STK *task_stk;
|
||
OS_ERR ucErr;
|
||
static u32_t i = 0;
|
||
|
||
arg = arg;
|
||
/*1111
|
||
//确定task优先级
|
||
if(prio){
|
||
ubPrio +=(prio-1); //确认优先权数组中有无优先级为(LWIP_TASK_START_PRIO+prio-1)的数
|
||
for(i=0; i= (LWIP_TASK_START_PRIO+LWIP_TASK_MAX) || i == LWIP_TASK_MAX){
|
||
LWIP_ASSERT( "sys_thread_new: there is no free priority", 0 );
|
||
return (-1);
|
||
}
|
||
}
|
||
*/
|
||
//确定task堆栈值
|
||
if(stacksize > LWIP_STK_SIZE || !stacksize)
|
||
stacksize = LWIP_STK_SIZE;
|
||
/* get Stack from pool */
|
||
//
|
||
CPU_STK * task_stk = OSMemGet( &StackMem, &ucErr );
|
||
task_stk = OSMemGet( &StackMem, &ucErr );
|
||
if(ucErr != OS_ERR_NONE){
|
||
//LWIP_ASSERT( "sys_thread_new: impossible to get a stack", 0 );
|
||
return (-1);
|
||
}
|
||
if(i < 6){
|
||
tsk_prio = i;
|
||
i++;
|
||
}
|
||
else
|
||
return (-1); //
|
||
|
||
tsk_prio = ubPrio-LWIP_TASK_START_PRIO;
|
||
OSTaskCreate(&LwIP_task_TCB[tsk_prio],
|
||
(CPU_CHAR *)name,
|
||
(OS_TASK_PTR )thread,
|
||
(void *)arg,
|
||
(OS_PRIO )prio,
|
||
//ubPrio,
|
||
(CPU_STK *)&task_stk[0],
|
||
(CPU_STK_SIZE )stacksize/10,
|
||
(CPU_STK_SIZE )stacksize,
|
||
(OS_MSG_QTY )0,
|
||
(OS_TICK )0,
|
||
(void *)0,
|
||
(OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
|
||
(OS_ERR *)&ucErr);
|
||
|
||
return ubPrio;
|
||
//return ubPrio;
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_arch_protect ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* This optional function does a "fast" critical region protection and
|
||
* returns the previous protection level. This function is only called
|
||
* during very short critical regions. An embedded system which supports
|
||
* ISR-based drivers might want to implement this function by disabling
|
||
* interrupts. Task-based systems might want to implement this by using
|
||
* a mutex or disabling tasking. This function should support recursive
|
||
* calls from the same task or interrupt. In other words,
|
||
* sys_arch_protect() could be called while already protected. In
|
||
* that case the return value indicates that it is already protected.
|
||
*
|
||
* sys_arch_protect() is only required if your port is supporting an
|
||
* operating system.
|
||
* Outputs:
|
||
* sys_prot_t -- Previous protection level (not used here)
|
||
*---------------------------------------------------------------------------*/
|
||
sys_prot_t sys_arch_protect( void )
|
||
{
|
||
CPU_SR cpu_sr;
|
||
|
||
OS_CRITICAL_ENTER();
|
||
|
||
return (( sys_prot_t )1);
|
||
}
|
||
/*---------------------------------------------------------------------------*
|
||
* Routine: sys_arch_unprotect ucosiii version
|
||
*---------------------------------------------------------------------------*
|
||
* Description:
|
||
* This optional function does a "fast" set of critical region
|
||
* protection to the value specified by pval. See the documentation for
|
||
* sys_arch_protect() for more information. This function is only
|
||
* required if your port is supporting an operating system.
|
||
* Inputs:
|
||
* sys_prot_t -- Previous protection level (not used here)
|
||
*---------------------------------------------------------------------------*/
|
||
void sys_arch_unprotect( sys_prot_t xValue )
|
||
{
|
||
CPU_SR cpu_sr;
|
||
OS_CRITICAL_EXIT();
|
||
}
|
||
/*
|
||
* Prints an assertion messages and aborts execution.
|
||
*/
|
||
/*
|
||
void sys_assert( const char *pcMessage )
|
||
{
|
||
(void) pcMessage;
|
||
for (;;) { }
|
||
}
|
||
*/
|
||
/** * @brief MilliSecond delay function based on FreeRTOS
|
||
* @param ms : Number of milliSeconds to delay
|
||
* @return Nothing
|
||
* Needed for some functions, do not use prior to FreeRTOS running
|
||
*/
|
||
void msDelay(CPU_INT32U ms)
|
||
{
|
||
OS_ERR ucErr;
|
||
OSTimeDly(ms, OS_OPT_TIME_DLY, &ucErr);
|
||
}
|
||
/*-------------------------------------------------------------------------*
|
||
* End of File: sys_arch.c
|
||
*-------------------------------------------------------------------------*/
|
||
#endif
|
||
/*-----------------------------------------------------------------------------------*/ |