void sys_init(void)//系统初始化
sys_thread_t sys_thread_new(void (* function)(void *arg), void *arg, int prio) //创建一个新进程
sys_mbox_t sys_mbox_new(void)//创建一个邮箱
voidsys_mbox_free(sys_mbox_t mbox)//释放并删除一个邮箱
voidsys_mbox_post(sys_mbox_t mbox, void *data) //发送一个消息到邮箱
void sys_mbox_fetch(sys_mbox_t mbox, void **msg)//等待邮箱中的消息
sys_sem_t sys_sem_new(u8_t count)//创建一个信号量
void sys_sem_free(sys_sem_t sem)//释放并删除一个信号量
void sys_sem_signal(sys_sem_t sem)//发送一个信号量
void sys_sem_wait(sys_sem_t sem)//等待一个信号量
void sys_timeout(u32_t msecs, sys_timeout_handler h, void *arg)//设置一个超时事件
void sys_untimeout(sys_timeout_handler h, void *arg)//删除一个超时事件

#define MAX_QUEUES20
#define MAX_QUEUE_ENTRIES20
typedef struct {
    OS_EVENT*pQ;//ucos中指向事件控制块的指针
    void*pvQEntries[MAX_QUEUE_ENTRIES];//消息队列
//MAX_QUEUE_ENTRIES消息队列中最多消息数
} TQ_DESCR, *PQ_DESCR;
typedef PQ_DESCRsys_mbox_t;//可见lwip中的mbox其实是ucos的消息队列
static char pcQueueMemoryPool[MAX_QUEUES * sizeof(TQ_DESCR) ];
void sys_init(void)
{
    u8_t i;
    s8_tucErr;
    pQueueMem = OSMemCreate( (void*)pcQueueMemoryPool, MAX_QUEUES, sizeof(TQ_DESCR), &ucErr );//为消息队列创建内存分区
//init lwip task prio offset
    curr_prio_offset = 0;
//init lwip_timeouts for every lwip task
//初始化lwip定时事件表,具体实现参考下面章节
    for (i = 0; LWIP_TASK_MAX; i++) {
        lwip_timeouts[i].next = NULL;
    }
}

u8_t curr_prio_offset ;
sys_thread_t sys_thread_new(void (* function)(void *arg), void *arg, int prio)
{
    if (curr_prio_offset < LWIP_TASK_MAX) {
        OSTaskCreate(function, (void*)0x1111, &LWIP_TASK_STK[curr_prio_offset][LWIP_STK_SIZE - 1],
                     LWIP_START_PRIO + curr_prio_offset );
        curr_prio_offset++;
        return 1;
    }
    else {
// PRINT(" lwip task prio out of range ! error! ");
    }
}

struct sys_timeout {
    struct sys_timeout *next;//指向下一个定时结构
    u32_t time;//定时时间
    sys_timeout_handler h;//定时时间到后执行的函数
    void *arg;//定时时间到后执行函数的参数.
};
struct sys_timeouts {
    struct sys_timeout *next;
};
struct sys_timeouts lwip_timeouts[LWIP_TASK_MAX];

struct sys_timeouts null_timeouts;
struct sys_timeouts * sys_arch_timeouts(void)
{
    u8_t curr_prio;
    s16_t err, offset;
    OS_TCB curr_task_pcb;
    null_timeouts.next = NULL;
//获取当前任务的优先级
    err = OSTaskQuery(OS_PRIO_SELF, &curr_task_pcb);
    curr_prio = curr_task_pcb.OSTCBPrio;
    offset = curr_prio - LWIP_START_PRIO;
//判断当前任务优先级是不是tcp/ip相关任务,优先级5-9
    if (offset < 0 || offset >= LWIP_TASK_MAX) {
        return &null_timeouts;
    }
    return &lwip_timeouts[offset];
}

void sys_timeout(u32_t msecs, sys_timeout_handler h, void *arg)
{
    struct sys_timeouts *timeouts;
    struct sys_timeout *timeout, *t;
    timeout = memp_malloc(MEMP_SYS_TIMEOUT);//为定时事件分配内存
    if (timeout == NULL) {
        return;
    }
    timeout->next = NULL;
    timeout->h = h;
    timeout->arg = arg;
    timeout->time = msecs;
    timeouts = sys_arch_timeouts();//返回当前任务定时事件链表起始指针
    if (timeouts->next == NULL) {//如果链表为空直接增加该定时事件
        timeouts->next = timeout;
        return;
    }
//如果链表不为空,对定时事件进行排序.注意定时事件中的time存储的是本事件
//时间相对于前一事件的时间的差值
    if (timeouts->next->time > msecs) {
        timeouts->next->time -= msecs;
        timeout->next = timeouts->next;
        timeouts->next = timeout;
    }
    else {
        for (t = timeouts->next; t != NULL; t = t->next) {
            timeout->time -= t->time;
            if (t->next == NULL ||
                t->next->time > timeout->time) {
                if (t->next != NULL) {
                    t->next->time -= timeout->time;
                }
                timeout->next = t->next;
                t->next = timeout;
                break;
            }
        }
    }
}

void sys_untimeout(sys_timeout_handler h, void *arg)
{
    struct sys_timeouts *timeouts;
    struct sys_timeout *prev_t, *t;
    timeouts = sys_arch_timeouts();//返回当前任务定时事件链表起始指针
    if (timeouts->next == NULL) { //如果链表为空直接返回
        return;
    }
//查找对应定时事件并从链表中删除.
    for (t = timeouts->next, prev_t = NULL; t != NULL; prev_t = t, t = t->next) {
        if ((t->h == h) && (t->arg == arg)) {
            /* We have a match */
            /* Unlink from previous in list */
            if (prev_t == NULL)
                timeouts->next = t->next;
            else
                prev_t->next = t->next;
            /* If not the last one, add time of this one back to next */
            if (t->next != NULL)
                t->next->time += t->time;
            memp_free(MEMP_SYS_TIMEOUT, t);
            return;
        }
    }
    return;
}

sys_mbox_t sys_mbox_new(void)
{
    u8_tucErr;
    PQ_DESCRpQDesc;
//从消息队列内存分区中得到一个内存块
    pQDesc = OSMemGet( pQueueMem, &ucErr );
    if ( ucErr == OS_NO_ERR ) {
//创建一个消息队列
        pQDesc->pQ = OSQCreate(&(pQDesc->pvQEntries[0]), MAX_QUEUE_ENTRIES );
        if ( pQDesc->pQ != NULL ) {
            return pQDesc;
        }
    }
    return SYS_MBOX_NULL;
}

const void * const pvNullPointer = 0xffffffff;
void sys_mbox_post(sys_mbox_t mbox, void *data)
{
    INT8U err;
    if ( !data )
        data = (void*)&pvNullPointer;
    err = OSQPost( mbox->pQ, data);
}

#define SYS_ARCH_TIMEOUT 0xffffffff
void sys_mbox_fetch(sys_mbox_t mbox, void **msg)
{
    u32_t time;
    struct sys_timeouts *timeouts;
    struct sys_timeout *tmptimeout;
    sys_timeout_handler h;
    void *arg;
again:
    timeouts = sys_arch_timeouts();////返回当前任务定时事件链表起始指针
    if (!timeouts || !timeouts->next) {//如果定时事件链表为空
        sys_arch_mbox_fetch(mbox, msg, 0);//无超时等待消息
    }
    else {
        if (timeouts->next->time > 0) {
//如果超时事件链表不为空,而且第一个超时事件的time !=0
//带超时等待消息队列,超时时间等于超时事件链表中第一个超时事件的time,
            time = sys_arch_mbox_fetch(mbox, msg, timeouts->next->time);
//在后面分析中可以看到sys_arch_mbox_fetch调用了ucos中的OSQPend系统调
//用从消息队列中读取消息.
//如果”mbox”消息队列不为空,任务立刻返回,否则任务进入阻塞态.
//需要重点说明的是sys_arch_mbox_fetch的返回值time:如果sys_arch_mbox_fetch
//因为超时返回,time=SYS_ARCH_TIMEOUT,
//如果sys_arch_mbox_fetch因为收到消息而返回,
//time = 收到消息时刻的时间-执行sys_arch_mbox_fetch时刻的时间,单位是毫秒
//由于在ucos中任务调用OSQPend系统调用进入阻塞态,到收到消息重新开始执行
//这段时间没有记录下来,所以我们要简单修改ucos的源代码.(后面我们会看到).
        }
        else {
//如果定时事件链表不为空,而且第一个定时事件的time ==0,表示该事件的定时
//时间到
            time = SYS_ARCH_TIMEOUT;
        }
        if (time == SYS_ARCH_TIMEOUT) {
//一个定时事件的定时时间到
            tmptimeout = timeouts->next;
            timeouts->next = tmptimeout->next;
            h = tmptimeout->h;
            arg = tmptimeout->arg;
            memp_free(MEMP_SYS_TIMEOUT, tmptimeout);
//从内存中释放该定时事件,并执行该定时事件中的函数
            if (h != NULL) {
                h(arg);
            }
//因为定时事件中的定时时间到或者是因为sys_arch_mbo_fetch超时到而执行到
//这里,返回本函数开头重新等待mbox的消息
            goto again;
        }
        else {
//如果sys_arch_mbox_fetch无超时收到消息返回
//则刷新定时事件链表中定时事件的time值.
            if (time <= timeouts->next->time) {
                timeouts->next->time -= time;
            }
            else {
                timeouts->next->time = 0;
            }
        }
    }
}
u32_tsys_arch_mbox_fetch(sys_mbox_t mbox, void **data, u32_t timeout)
{
    u32_tucErr;
    u16_t ucos_timeout;
//在 lwip中 ,timeout的单位是ms
// 在ucosII ,timeout 的单位是timer tick
    ucos_timeout = 0;
    if (timeout != 0) {
        ucos_timeout = (timeout ) * ( OS_TICKS_PER_SEC / 1000);
        if (ucos_timeout < 1)
            ucos_timeout = 1;
        else if (ucos_timeout > 65535)
            ucos_timeout = 65535;
    }
//如果data!=NULL就返回消息指针,
    if (data != NULL) {
        *data = OSQPend( mbox->pQ, (u16_t)ucos_timeout, &ucErr );
    }
    else {
        OSQPend(mbox->pQ, (u16_t)ucos_timeout, &ucErr);
    }
//这里修改了ucos中的OSQPend系统调用,
//原来的void*OSQPend (OS_EVENT *pevent, INT16U timeout, INT8U *err)
// err的返回值只有两种:收到消息就返回OS_NO_ERR,超时则返回OS_TIMEOUT
//这里先将err从8位数据改变成了16位数据 OSQPend(*pevent,timeout, INT16U *err)
//重新定义了OS_TIMEOUT
//在ucos中原有#define OS_TIMEOUT 20
//改为 #defineOS_TIMEOUT-1
//err返回值的意义也改变了,如果超时返回OS_TIMEOUT
// 如果收到消息,则返回OSTCBCur->OSTCBDly修改部分代码如下
//if (msg != (void *)0) { /* Did we get a message?*/
// OSTCBCur->OSTCBMsg = (void *)0;
// OSTCBCur->OSTCBStat= OS_STAT_RDY;
// OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;
// *err = OSTCBCur->OSTCBDly;// zhangzs @2003.12.12
//OS_EXIT_CRITICAL();
// return (msg);/* Return message received */
//}
//关于ucos的OSTBCur->OSTCBDly的含义请查阅ucos的书籍
    if ( ucErr == OS_TIMEOUT ) {
        timeout = SYS_ARCH_TIMEOUT;
    }
    else {
        if (*data == (void*)&pvNullPointer )
            *data = NULL;
//单位转换,从ucos tick->ms
        timeout = (ucos_timeout - ucErr) * (1000 / OS_TICKS_PER_SEC);
    }
    return timeout;
}