lwip移植说明及心得

　　lwIP是瑞士计算机科学院（Swedish Institute of Computer Science）的Adam Dunkels等开发的一套用于嵌入式系统的开放源代码TCP/IP协议栈。Lwip既可以移植到操作系统上，又可以在无操作系统的情况下独立运行。

　　1、LwIP的特性

　　（1） 支持多网络接口下的IP转发

　　（2） 支持ICMP协议

　　（3） 包括实验性扩展的的UDP（用户数据报协议）

　　（4） 包括阻塞控制，RTT估算和快速恢复和快速转发的TCP（传输控制协议）

　　（5） 提供专门的内部回调接口（Raw API）用于提高应用程序性能

　　（6） 可选择的Berkeley接口API（多线程情况下）

　　（7） 在最新的版本中支持ppp

　　（8） 新版本中增加了的IP fragment的支持。

　　（9） 支持DHCP协议，动态分配ip地址。

　　2 Lwip在ucos上的移植。

　　2.1 系统初始化

　　sys_int必须在tcpip协议栈任务tcpip_thread创建前被调用。

　　#define MAX_QUEUES 20

　　#define MAX_QUEUE_ENTRIES 20

　　typedef struct {

　　OS_EVENT* pQ;//ucos中指向事件控制块的指针

　　void* pvQEntries［MAX_QUEUE_ENTRIES］;//消息队列

　　//MAX_QUEUE_ENTRIES消息队列中最多消息数

　　} TQ_DESCR， *PQ_DESCR;

　　typedef PQ_DESCR sys_mbox_t;//可见lwip中的mbox其实是ucos的消息队列

　　static char pcQueueMemoryPool［MAX_QUEUES * sizeof（TQ_DESCR） ］;

　　void sys_init（void）

　　{

　　u8_t i;

　　s8_t ucErr;

　　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;i《LWIP_TASK_MAX;i++）{

　　lwip_timeouts［i］.next = NULL;

　　}

　　}

　　2.2 创建一个和tcp/ip相关新进程

　　lwip中的进程就是ucos中的任务，创建一个新进程的代码如下：

　　#define LWIP_STK_SIZE 10*1024//和tcp/ip相关任务的堆栈大小。可以根据情况自

　　//己设置，44b0开发板上有8M的sdram，所以设大

　　//一点也没有关系：）

　　//max number of lwip tasks

　　#define LWIP_TASK_MAX 5 //和tcp/ip相关的任务最多数目

　　//first prio of lwip tasks

　　#define LWIP_START_PRIO 5 //和tcp/ip相关任务的起始优先级，在本例中优先级可

　　//以从（5-9）。注意tcpip_thread在所有tcp/ip相关进程中//应该是优先级最高的。在本例中就是优先级5

　　//如果用户需要创建和tcp/ip无关任务，如uart任务等，

　　//不要使用5-9的优先级

　　OS_STK LWIP_TASK_STK［LWIP_TASK_MAX］［LWIP_STK_SIZE］;//和tcp/ip相关进程

　　//的堆栈区

　　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！ ”）;

　　}

　　}

　　从代码中可以看出tcpip_thread应该是最先创建的。

　　2.3 Lwip中的定时事件

　　在tcp/ip协议中很多时候都要用到定时，定时的实现也是tcp/ip协议栈中一个重要的部分.lwip中定时事件的数据结构如下。

　　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］;

　　Lwip中的定时事件表的结构如下图，每个和tcp/ip相关的任务的一系列定时事件组成一个单向链表。每个链表的起始指针存在lwip_timeouts的对应表项中。

　　函数sys_arch_timeouts返回对应于当前任务的指向定时事件链表的起始指针。该指针存在lwip_timeouts［MAX_LWIP_TASKS］中。

　　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］;

　　}

　　注意：杨晔大侠移植的代码在本函数有一个bug.杨晔大侠的移植把上面函数中的OS_TCB curr_task_tcb定义成了全局变量，使本函数成为了一个不可重入函数。我也是在进行如下测试时发现了这个bug.我的开发板上设置的ip地址是192.168.1.95.我在windows的dos窗口内运行

　　ping 192.168.1.95 –l 2000 –t，不间断用长度为2000的数据报进行ping测试，同时使用tftp客户端软件给192.168.1.95下载一个十几兆程序，同时再使用telnet连接192.168.1.95端口7（echo端口），往该端口写数测试echo功能。

　　在运行一段时间以后，开发板进入不再响应。我当时也是经过长时间的分析才发现是因为在低优先级任务运行ys_arch_timeouts（）时被高优先级任务打断改写了curr_task_tcb的值，从而使sys_arch_timeouts返回的指针错误，进而导致系统死锁。函数sys_timeout给当前任务增加一个定时事件：

　　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;

　　}

　　}

　　}

　　}

　　函数sys_untimeout从当前任务定时事件链表中删除一个定时事件

　　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;

　　}

　　2.2.3 “mbox”的实现：

　　（1）mbox的创建

　　sys_mbox_t sys_mbox_new（void）

　　{

　　u8_t ucErr;

　　PQ_DESCR pQDesc;

　　//从消息队列内存分区中得到一个内存块

　　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;

　　}

　　（2）发一条消息给”mbox”

　　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）;

　　}

　　在ucos中，如果OSQPost （OS_EVENT *pevent， void *msg）中的msg==NULL 会返回一条OS_ERR_POST_NULL_PTR错误。而在lwip中会调用sys_mbox_post（mbox，NULL）发送一条空消息，我们在本函数中把NULL变成一个常量指针0xffffffff.

　　（3）从”mbox”中读取一条消息

　　#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_t sys_arch_mbox_fetch（sys_mbox_t mbox， void **data， u32_t timeout）

　　{

　　u32_t ucErr;

　　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

　　//改为 #define OS_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;

　　}

　　semaphone的实现和mbox类似，这里就不再重复了.

　　3、LwIP移植心得

　　平台是LPC2136+ENC28J60，32K的RAM，软件是uCOS-II 2.51+LwIP 1.1.1。

　　感觉主要解决两个问题：

　　操作系统仿真层的移植。这个基于uCOS-II的代码太多了。COPY下就行！

　　1）设备驱动的移植

　　驱动的移植主要就是完成ethernetif.c的工作。作者已经给好了驱动的接口。

　　struct netif {

　　struct netif *next;

　　struct ip_addr ip_addr;

　　struct ip_addr netmask;

　　struct ip_addr gw;

　　err_t （* input）（struct pbuf *p， struct netif *inp）;

　　err_t （* output）（struct netif *netif， struct pbuf *p，

　　struct ip_addr *ipaddr）;

　　err_t （* linkoutput）（struct netif *netif， struct pbuf *p）;

　　void *state;

　　#if LWIP_DHCP

　　struct dhcp *dhcp;

　　#endif

　　unsigned char hwaddr_len;

　　unsigned char hwaddr［NETIF_MAX_HWADDR_LEN］;

　　u16_t mtu;

　　char name［2］;

　　u8_t num;

　　u8_t flags;

　　};

　　主要就是：

　　err_t （* input）（struct pbuf *p， struct netif *inp）;

　　这个是被驱动调用的，传递一个数据包给TCP/IP栈。

　　err_t （* output）（struct netif *netif， struct pbuf *p，struct ip_addr *ipaddr）;

　　这个是被IP模块调用的，向以太网上发送一个数据包，函数要先通过IP地址获得解决硬件地址，然后发包。

　　err_t （* linkoutput）（struct netif *netif， struct pbuf *p）;

　　这个是直接发送数据包的接口。

　　相应的作者在ethernetif.c里面给了几个函数框架，这个文件相当于一个硬件抽象层。

　　static void low_level_init（struct netif *netif）

　　网卡初始化函数

　　static err_t low_level_output（struct netif *netif， struct pbuf *p）

　　链路层发送函数，实现err_t （* linkoutput）接口。

　　static struct pbuf *low_level_input（struct netif *netif）

　　得到一整帧数据

　　static err_t ethernetif_output（struct netif *netif， struct pbuf *p，struct ip_addr *ipaddr）

　　实现发送线程，实现err_t （* output）接口。

　　static void ethernetif_input（struct netif *netif）

　　实现接收线程，识别数据包是ARP包还是IP包

　　err_t ethernetif_init（struct netif *netif）

　　初始化底层接口，给作者给好了驱动的接口赋值啊啥的。

　　其实，写驱动的时候只要自己再建个ethernet.c，实际的网络硬件控制的文件

　　然后提供几个函数

　　比如：

　　void EMACInit（ void ）

　　硬件的初始化

　　void EMACPacketSend （ u8_t *buffer， u16_t length ）

　　用来将buffer里面的包复制到网络设备的发送缓冲里面，发送。

　　u16_t EMACPacketReceive （ u8_t *buffer， u16_t max_length ）

　　用来将网络设备的接收缓冲里面的包数据复制到buffer里面。

　　u16_t EMACPacketLength （ u16_t max_length ）

　　获得包长度

　　还有其他控制类函数。

　　最后，用ethernet.c里的函数完成ethernetif.c里的框架。这样脉络可能会清楚一点。

　　2）应用层的那边问题

　　（1）.lwip提供三种API：1）RAW API 2）lwip API 3）BSD API。

　　对于多任务系统而言，因为lwip采用的是将TCP/IP协议放在一个单独的线程里面，所以那个线程是tcpip_thread。采用RAW API回调技术，就得把应用层程序写在tcpip_thread这个线程里面，作为同一个任务运行。

　　而采用lwip API，就可以将TCP/IP协议和应用层程序放在不同的任务里面，通过调api_lib.c提供的函数，编写相应的应用层代码。好象一般都会采用这种方式。

　　BSD API就是那sockets.c里面的，没用过。

　　（2）任务间是如何调度的

　　从底层到应用层，一般将底层数据接收做为一个线程，可以建个任务也可以直接在中断里解决。

　　然后tcpip_thread是一个线程，最后是应用层一个线程。

　　底层的邮箱投递活动是通过调用tcpip.c里的tcpip_input。这个函数向tcpip_thread投递消息。高层的投递应该是通过tcpip_apimsg。

　　遇到的问题：

　　一开始移植的时候，驱动写好的，能PING通，但TCP的任务没反应，这个我那问题是lwip协议栈的问题，换个版本的协议栈就搞定了，网上吧，下的协议栈，有的是有问题的。