图2.4-1 ARM Image映像文件结构

3.1 ucos简介

当产生外部间断或许体系反常时，ARM会进入相应的方法，各种运转方法均有其独立的仓库空间。UCOS中的使命是调度的最小单元，每个使命都有自己独立的仓库空间，当使命运转时，它用来保存一些局部变量，当使命挂起时，它担任保存使命的运转现场，也便是CPU寄存器的值。

体系时钟是UCOS办理使命延时的根本依据，要求有一个周期性的守时器产生固定距离时刻。咱们运用LPC2220的守时器0产生固守时刻距离事情，时刻距离设置为10ms，守时时刻到产生间断。UCOS体系时钟处理函数是OSTimeTick()，时刻间断服务程序里调用此函数即可。

4.Lwip移植

4.1 lwip简介

lwip是瑞典核算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。LwIP是Light Weight (轻型)IP协议，有无操作体系的支撑都能够运转。LwIP完结的重点是在坚持TCP协议首要功用的基础上削减对RAM 的占用，它只需十几KB的RAM和40K左右的ROM就能够运转，这使LwIP协议栈适合在低端的嵌入式体系中运用。

4.2 lwip移植总述

Lwip有无操作体系的支撑都能够运转，咱们移植是依据UCOS的。
依据UCOS移植Lwip首要包含两个方面的作业：
1. 依据Lwip供给的操作体系模仿层接口编写依据UCOS的完结代码，以完结Lwip和UCOS的完美交融。
2. 依据Lwip供给的底层网卡驱动接口，结合RTL8019AS网卡datasheet编制网卡驱动程序。

4.3移植lwip操作体系模仿层

操作体系模仿层（sys_arch）存在的意图首要是为了便利 LwIP 的移植，它在底层操作体系和LwIP 之间供给了一个接口。这样，咱们在移植 LwIP 到一个新的方针体系时，只需修正这个接口即可。不过，不依赖底层操作体系的支撑也能够完结这个接口。
sys_arch需求为LwIP供给创立新线程功用，供给信号量 （semaphores） 和邮箱 （mailboxes） 两种进程间通讯方法 （IPC） 。
1. 模仿层需求增加的头文件 cc.h 阐明
Lwip运用的数据类型界说：
typedef unsigned char u8_t;
typedef signed char s8_t;
typedef unsigned short u16_t;
typedef signed short s16_t;
typedef unsigned int u32_t;
typedef signed int s32_t;
typedef unsigned int sys_prot_t;
typedef unsigned int mem_ptr_t;
lwip运用的结构体对齐方法声明相关的宏界说：
#define PACK_STRUCT_FIELD(x) x
#define PACK_STRUCT_STRUCT
#define PACK_STRUCT_BEGIN __packed
#define PACK_STRUCT_END
为便利操作协议帧数据，lwip协议栈中结构体运用单字节对齐方法。
处理器方法：
#define BYTE_ORDER LITTLE_ENDIAN
咱们运用的LPC2220为小端方法处理器，故界说为小端方法。
其他内容首要和调试输出功用有关，这儿不进行逐个阐明。
2. 需求完结的操作体系模仿层函数
– void sys_init(void)

初始化lwip操作体系模仿层。

– sys_sem_t sys_sem_new(u8_t count)

创立一个信号量，count总共初始化后的信号量状况。

– void sys_sem_free(sys_sem_t sem)

删去指定的信号量。

– void sys_sem_signal(sys_sem_t sem)

发送一个信号量。

– u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
等候指定的信号并堵塞线程。timeout 参数为 0，线程会一向被堵塞至收到指定的信号；非 0，则线程仅被堵塞至指定的 timeout时刻（单位为毫秒）。在timeout 参数值非 0 的状况下，回来值为等候指定的信号所耗费的毫秒数。假如在指定的时刻内并没有收到信号，回来值为SYS_ARCH_TIMEOUT。假如线程不用再等候这个信号（也便是说，现已收到信号） ，回来值也能够为 0。留意，LwIP完结了一个称号与之类似的函数来调用这个函数，sys_sem_wait()，留意差异。
– sys_mbox_t sys_mbox_new(void)
创立一个空音讯邮箱。

– void sys_mbox_free(sys_mbox_t mbox)
开释一个邮箱。

– void sys_mbox_post(sys_mbox_t mbox, void *msg)
投递音讯“msg”到指定的邮箱“mbox” 。

– u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout)
堵塞线程直至邮箱收到至少一条音讯。最长堵塞时刻由 timeout 参数指定（与
sys_arch_sem_wait()函数类似） 。msg 是一个成果参数，用来保存邮箱中的音讯指针 （即*msg = ptr） ，它的值由这个函数设置。 “msg”参数有或许为空，这标明当时这条音讯应该被丢掉。 回来值与 sys_arch_sem_wait()函数相同：等候的毫秒数或许 SYS_ARCH_TIMEOUT――假如时刻溢出的话。LwIP完结的函数中，有一个称号与之类似的――sys_mbox_fetch()，留意委任。

– struct sys_timeouts *sys_arch_timeouts(void)
回来一个指向当时线程运用的 sys_timeouts 结构的指针。LwIP 中，每一个线程都有一个timeouts 链表，这个链表由 sys_timeout 结构组成，sys_timeouts 结构则保存了指向这个链表的指针。这个函数由 LwIP 的超时调度程序调用，而且不能回来一个空（NULL）值。 单线程 sys_arch 完结中，这个函数只需简略回来一个指针即可。这个指针指向保存在 sys_arch 模块中的 sys_timeouts 全局变量。

– sys_thread_t sys_thread_new(void (* thread)(void *arg), void *arg, int prio)

创立一个新的线程。

完结sys_sem_t sys_sem_new(u8_t count)函数：
sys_sem_t sys_sem_new(u8_t count)
{
return OSSemCreate((u16_t)count);
}
这个函数完结比较简略，UCOS供给了信号量的操作函数，直接调用即可。
完结void sys_sem_free(sys_sem_t sem)函数：
void sys_sem_free(sys_sem_t sem)
{
u8_t Err;
OSSemDel(sem, OS_DEL_ALWAYS, &Err);
}
完结void sys_sem_signal(sys_sem_t sem)函数：
void sys_sem_signal(sys_sem_t sem)
{
OSSemPost(sem);
}
完结u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)函数：
u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
{
u8_t Err;
u32_t wait_ticks;

if (OSSemAccept(sem))/* 假如现已收到, 则回来0 */
{
return 0;
}

wait_ticks = 0;
if(timeout!=0){
wait_ticks = (timeout * OS_TICKS_PER_SEC)/1000;
if(wait_ticks < 1)
wait_ticks = 1;
else if(wait_ticks > 65535)
wait_ticks = 65535;
}

OSSemPend(sem, (u16_t)wait_ticks, &Err);

if (Err == OS_NO_ERR)
return timeout/2; //将等候时刻设置为timeout/2
else
return SYS_ARCH_TIMEOUT;
}
堵塞进程，等候一个信号量的到来。假如timeout不为0，则进程堵塞的时刻最多为相关的毫秒数，不然进程一向堵塞，直到收到信号量。
回来值：假如timeout不为0，则回来值为等候该信号量的毫秒数，假如函数在规则的时刻内没有比及信号量，则回来值为SYS_ARCH_TIMEOUT，假如信号量在调用函数时现已可用，则函数不会产生任何堵塞操作，回来值这时能够是0。
完结sys_mbox_t sys_mbox_new(int size)函数功用：
sys_mbox_t sys_mbox_new(int size)
{
u8_t Err;
sys_mbox_t pQDesc;

pQDesc = OSMemGet( MboxMem, &Err );
if( Err == OS_NO_ERR ) {
pQDesc->ucos_queue = OSQCreate( &(pQDesc->mbox_msg_entris[0]), MAX_MSG_IN_MBOX );
if( pQDesc->ucos_queue != NULL ) {
return pQDesc;
}
else{
OSMemPut(MboxMem,pQDesc);
}
}
return SYS_MBOX_NULL;
}
邮箱用于音讯传递，用户即能够将其完结为一个行列，答应多条音讯投递到这个邮箱，也能够每次只答应投递一个音讯，这两种方法 LwIP都能够正常运作。不过，前者愈加有用。这儿咱们运用音讯行列的方法，答应投递多条音讯。
完结void sys_mbox_free(sys_mbox_t mbox)函数：
void sys_mbox_free(sys_mbox_t mbox)
{
u8_t Err;

OSQFlush(mbox->ucos_queue);

OSQDel(mbox->ucos_queue, OS_DEL_ALWAYS, &Err);

OSMemPut( MboxMem, mbox );
}
完结void sys_mbox_post(sys_mbox_t mbox, void *msg)函数功用：
void sys_mbox_post(sys_mbox_t mbox, void *msg)
{
if (msg == NULL)
msg = (void*)&NullMessage;//处理空指针投递的问题
while (OSQPost(mbox->ucos_queue, msg) == OS_Q_FULL)
OSTimeDly(10);
}
完结u32_t
sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout)函数：
u32_t
sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout)
{
u8_t Err;
u32_t wait_ticks;
void *Data;

Data = OSQAccept(mbox->ucos_queue);
if (Data != NULL)
{
if (Data == (void*)&NullMessage)
{
*msg = NULL;
}
else
{
*msg = Data;
}
return 0;
}

wait_ticks = 0;
if(timeout!=0){
wait_ticks = (timeout * OS_TICKS_PER_SEC)/1000;
if(wait_ticks < 1)
wait_ticks = 1;
else if(wait_ticks > 65535)
wait_ticks = 65535;
}

Data = OSQPend(mbox->ucos_queue, (u16_t)wait_ticks, &Err);

if (Data != NULL)
{
if (Data == (void*)&NullMessage)
{
*msg = NULL;
}
else
{
*msg = Data;
}
}

if (Err == OS_NO_ERR)
return timeout/2; //将等候时刻设置为timeout/2
else
return SYS_ARCH_TIMEOUT;
}
完结struct sys_timeouts * sys_arch_timeouts(void)函数功用：
struct sys_timeouts * sys_arch_timeouts(void)
{
return &global_timeouts;
}
完结sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio)函数功用：
sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio)
{
static u32_t TaskCreateFlag=0;
u8_t i=0;
name=name;
stacksize=stacksize;

while((TaskCreateFlag>>i)&0x01){
if(ii++;
else return 0;
}
if(OSTaskCreate(thread,(void*)arg, &LWIP_STK_AREA[i][LWIP_STK_SIZE-1],prio)==OS_NO_ERR){
TaskCreateFlag |=(0x01<};

return prio;
}
新建一个进程，在整个体系中只会被调用一次。
移植操作体系模仿层完结。

4.4 依据lwip供给的软件架构编写相应的网卡芯片驱动

从用户编程视点看，针对RTL8019AS的操作实践上便是对RTL8019AS内部寄存器的操作，以完结网卡的初始化、数据发送、数据接纳等操作。发送数据时，主操控器将数据写入网卡的SRAM中，然后发送一个发送数据指令，网卡就会将数据封装成规范以太网物理层数据帧发送出去。同理，网卡接纳到以太网数据时，网卡会主动解析成高层运用的有用格局，放在内部SRAM中供主控芯片读取，咱们选用周期查询方法完结接纳数据的处理。
RTL8019AS与主控芯片间通讯的输入/输出地址共有32个，地址偏移量为00H-1FH。其间00-0F共16个地址，为内部寄存器地址，RTL8019AS的内部寄存器每个都是8位的，一切寄存器总共分为4页，每一页都同享这16个偏移量，当时那一页有用是由CR寄存器的值决议的。

要接纳和发送数据包都有必要读写网卡的内部的16k的ram,有必要经过DMA进行读和写.网卡的内部ram是一块双端口的16k字节的ram.所谓双端口便是说有两套总线衔接到该ram,一套总线A是网卡操控器读/写网卡上的ram,另一套总线B是主操控器读/写网卡上的ram.总线A又名Local DMA,总线B又名Remote DMA.
长途DMA地址包含10H～17H，都能够用来做长途DMA端口，只需用其间的一个就能够了。咱们运用10H。
复位端口包含18H～1FH共8个地址，功用相同，用于RTL8019AS复位。咱们运用18H。

Lwip供给了网卡驱动结构方法，咱们只需依据实践运用的网卡特性完善这些函数就能够了。
详细说咱们应该完结以5个函数的完结。
static void low_level_init(struct netif *netif)。
static err_t low_level_output(struct netif *netif, struct pbuf *p)
static struct pbuf *low_level_input(struct netif *netif)
err_t ethernetif_init(struct netif *netif)
static void ethernetif_input(struct netif *netif)
前3个函数与网卡驱动函数密切相关。low_level_init为网卡初始化函数，首要用来完结网卡的复位及参数初始化。low_level_output为网卡数据包发送函数。low_level_input为网卡数据包接纳函数。
ethernetif_input函数首要效果是调用网卡数据包接纳函数low_level_input从网卡SRAM中读取一个数据包，然后解析数据包类型，然后交付给上层运用程序。实践上，ethernetif_input现已是一个能够直接运用的函数，调用一次能够完结数据包的接纳和递送。咱们在运用层树立一个使命周期性调用该函数完结接纳数据包的功用。
ethernetif_init是上层运用在办理网络接口结构netif时调用的函数。该函数首要完结netif结构中的某些字段初始化，并终究调用low_level_init函数完结网卡的初始化。
low_level_init函数完结源代码：
static void
low_level_init(struct netif *netif)
{
struct ethernetif *ethernetif = netif->state;

/* set MAC hardware address length */
netif->hwaddr_len = ETHARP_HWADDR_LEN;

/* set MAC hardware address */
netif->hwaddr[0] = MyMacID[0];
netif->hwaddr[1] = MyMacID[1];
netif->hwaddr[2] = MyMacID[2];
netif->hwaddr[3] = MyMacID[3];
netif->hwaddr[4] = MyMacID[4];
netif->hwaddr[5] = MyMacID[5];

/* maximum transfer unit */
netif->mtu = 1500;

/* device capabilities */
/* dont set NETIF_FLAG_ETHARP if this device is not an ethernet one */
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;

/* Do whatever else is needed to initialize interface. */
board_eth_init();
}
netif结构体是协议栈内核对体系网络接口设备进行办理的重要数据结构，内核会为每个网络接口分配一个netif结构，用于描绘接口特点。上面函数初始化了hwaddr、mtu、flag等要害特点域，并最终调用board_eth_init函数。
board_eth_init函数源代码如下：
void board_eth_init(void)
{
unsigned char i;
unsigned char j;

IODIR=IODIR|RSTDRV;
IOCLR=RSTDRV;
for(i=0;i<200;i++)
{
for(j=0;j<200;j++);
}
IOSET=RSTDRV;
for(i=0;i<200;i++)
{
for(j=0;j<200;j++);
}
IOCLR=RSTDRV;
for(i=0;i<200;i++)
{
for(j=0;j<200;j++);
}

NE_RESET = 0x12;
Delay(500);
NE_CR = ENCR_PAGE0 + ENCR_NODMA;
NE_DCR = NE_DCRVAL;
NE_RBCR0 = 0x00; /* MSB remote byte count reg */
NE_RBCR1 = 0x00; /* LSB remote byte count reg */
NE_TPSR = TX_START_PG;
NE_PSTART = RX_START_PG ; /* DMA START PAGE 46h */
NE_PSTOP = RX_STOP_PG; /* Ending page +1 of ring buffer */
NE_BNRY = RX_START_PG;/* Boundary page of ring buffer */
NE_RCR = ENRCR_RXCONFIG;
NE_TCR = ENTCR_TXCONFIG; /* xmit on. */
NE_ISR = 0xff; /* Individual bits are cleared by writing a “1” into it. */
NE_IMR = ENIMR_RX; // by Forrest..
NE_CR = ENCR_PAGE1 + ENCR_NODMA;
NE_PAR0 = MyMacID[0];
NE_PAR1 = MyMacID[1];
NE_PAR2 = MyMacID[2];
NE_PAR3 = MyMacID[3];
NE_PAR4 = MyMacID[4];
NE_PAR5 = MyMacID[5];
NE_MAR0 = 0xff;
NE_MAR1 = 0xff;
NE_MAR2 = 0xff;
NE_MAR3 = 0xff;
NE_MAR4 = 0xff;
NE_MAR5 = 0xff;
NE_MAR6 = 0xff;
NE_MAR7 = 0xff;
NE_CURR = RX_START_PG; /* RX_CURR_PG; Current memory page = RX_CURR_PG ? */

NE_CR = ENCR_PAGE0 + ENCR_NODMA + ENCR_START;
}
board_eth_init函数是确保网卡RTL8019AS正常作业的条件，它首要完结网卡的硬件复位，然后进行网卡的软件复位（往0X18端口写入恣意值使其软复位），接着初始化网卡装备中的发送、接纳缓冲区的页地址、装备了网卡发送装备寄存器、接纳寄存器，最终设置网卡本身的物理地址和多播过滤地址。
low_level_output函数，上层运用层数据需求封装成协议栈要求的pbuf数据格局，然后再操作网卡发送数据。其源代码如下：
static err_t
low_level_output(struct netif *netif, struct pbuf *p)
{
struct pbuf *q;

u8_t isr;
u8_t chain=0;
u8_t * tr_ptr;
u16_t tr_len, temp_dw;
u16_t padLength,packetLength;

/* Set up to transfer the packet contents to the NIC RAM. */
padLength = 0;
packetLength = p->tot_len;

/* packetLength muse >=64 (see 802.3) */
if ((p->tot_len) < 64)
{
padLength = 64 – (p->tot_len);
packetLength = 64;
}

/* dont close nic,just close receive interrupt */
NE_CR = ENCR_PAGE2 | ENCR_NODMA | ENCR_START;
isr = NE_IMR;
isr &= ~ENISR_RX;
NE_CR = ENCR_PAGE0 | ENCR_NODMA | ENCR_START;
NE_IMR = isr;

NE_ISR = ENISR_RDC;

/* Amount to send */
NE_RBCR0 = packetLength & 0xff;
NE_RBCR1 = packetLength >> 8;

/* Address on N%&&&&&% to store */
NE_RSAR0 = 0x00;
NE_RSAR1 = NE_START_PG;

/* Write command to start */
NE_CR = ENCR_PAGE0 | ENCR_RWRITE | ENCR_START;

/* write packet to ring buffers. */
for(q = p, chain = 0; q != NULL; q = q->next)
{
if(chain == 1)
{
if(((q->len-1) & 0x01) && (q->next != NULL))
{
tr_len = q->len – 2;
tr_ptr = ((u8_t*)q->payload) + 1;

temp_dw = *(((u8_t *)q->payload) + q->len – 1);
temp_dw += *(u8_t *)(q->next->payload) << 8;

chain = 1;
}
else
{
tr_len = q->len – 1;
tr_ptr = ((u8_t*)q->payload) + 1;
chain = 0;
}
}
else
{
if((q->len & 0x01) && (q->next != NULL))
{
tr_len = q->len – 1;
tr_ptr = (u8_t*)q->payload;

temp_dw = *(((u8_t *)q->payload) + q->len – 1);
temp_dw += *(u8_t *)(q->next->payload) << 8;

chain = 1;
}
else
{
tr_len = q->len;
tr_ptr = (u8_t*)q->payload;

chain = 0;
}
}

ne2k_copyout(tr_len, tr_ptr);

if (chain == 1) NE_DATAW = temp_dw;

}
if(padLength>0)
ne2k_outpad(padLength);

/* Wait for remote dma to complete – ISR Bit 6 clear if busy */
while((u8_t)(NE_ISR & ENISR_RDC) == 0 );

/* clear RDC */
NE_ISR = ENISR_RDC;

/* Issue the transmit command.(start local dma) */
NE_TPSR = NE_START_PG;
NE_TBCR0 = packetLength & 0xff;
NE_TBCR1 = packetLength >> 8;

/* Start transmission (and shut off remote dma) */
NE_CR = ENCR_PAGE0 | ENCR_NODMA | ENCR_TRANS | ENCR_START;
/* reopen receive interrupt */
NE_CR = ENCR_PAGE2 | ENCR_NODMA | ENCR_START;
isr = NE_IMR;
isr |= ENISR_RX;
NE_CR = ENCR_PAGE0 | ENCR_NODMA | ENCR_START;
NE_IMR = isr;

#ifdef LINK_STATS
lwip_stats.link.xmit++;
#endif /* LINK_STATS */

return ERR_OK;
}
low_level_input函数从网卡读取数据，封装成pbuf方法后传递给上层运用层。其源代码如下：
static struct pbuf *
low_level_input(struct netif *netif)
{
struct pbuf *p, *q;
u16_t packetLength, len;
u8_t PDHeader[18]; /* Temp storage for ethernet headers */
u8_t * payload;

NE_ISR = ENISR_RDC;
// NE_RBCR1 = 0x0f; /* See controller manual , use send packet command */
NE_CR = ENCR_PAGE0 | ENCR_RREAD | ENCR_RWRITE | ENCR_START;
// NE_CR = ENCR_PAGE0 | ENCR_RREAD | ENCR_START;
/* get the first 18 bytes from nic */
ne2k_copyin(18,PDHeader);

/* Store real length, set len to packet length – header */
packetLength = ((unsigned) PDHeader[2] | (PDHeader[3] << 8 ));

/* verify if the packet is an IP packet or ARP packet */
if((PDHeader[3]>0x06)||(PDHeader[16] != 8)||(PDHeader[17] != 0 && PDHeader[17] != 6))
{
ne2k_discard(packetLength-14);
return NULL;
}

/* We allocate a pbuf chain of pbufs from the pool. */
p = pbuf_alloc(PBUF_RAW, packetLength, PBUF_POOL);

if (p != NULL) {
/* We iterate over the pbuf chain until we have read the entire
packet into the pbuf. */

/* This assumes a minimum pbuf size of 14 … a good assumption */
memcpy(p->payload, PDHeader + 4, 14);

for(q = p; q != NULL; q = q->next) {
/* Read enough bytes to fill this pbuf in the chain. The
available data in the pbuf is given by the q->len
variable. */
payload = q->payload;
len = q->len;
if (q == p) {
payload += 14;
len -=14;
}

ne2k_copyin(len,payload);
}

#ifdef LINK_STATS
lwip_stats.link.recv++;
#endif /* LINK_STATS */
} else {
/* no more PBUF resource, Discard packet in buffer. */
ne2k_discard(packetLength-14);
#ifdef LINK_STATS
lwip_stats.link.memerr++;
lwip_stats.link.drop++;
#endif /* LINK_STATS */
}

return p;
}
Lwip要求的协议栈底层操作网卡的函数编写结束。

4.5 移植完结后测验TCP/IP协议栈

咱们运用查询方法读取网卡数据包，详细计划是建一个查询使命，周期性调用GetPacket()函数，函数源代码：
void GetPacket(void)
{
u8_t isr,curr,bnry;

NE_CR = ENCR_PAGE0 | ENCR_NODMA;
isr = NE_ISR;

/* got packet with no errors */
if (isr & ENISR_RX) {

NE_ISR = ENISR_RX;

NE_CR = ENCR_PAGE1 | ENCR_NODMA;
curr = NE_CURR;
NE_CR = ENCR_PAGE0 | ENCR_NODMA;
bnry = NE_BNRY;
/* get more than one packet until receive buffer is empty */
while(curr != bnry) {
ethernetif_input(&rtl8019_netif);
NE_CR = ENCR_PAGE1 | ENCR_NODMA;
curr = NE_CURR;
NE_CR = ENCR_PAGE0 | ENCR_NODMA;
bnry = NE_BNRY;
}
// rBNRY = NE_BNRY;
}
else {
NE_ISR = 0xFF;
};
}
在测验lwip协议栈前，咱们需求初始化。初始化代码：
struct netif rtl8019_netif;
struct netif loop_netif;
extern err_t ethernetif_init(struct netif *netif);

void lwip_init_task(void)
{
struct ip_addr ipaddr, netmask, gw;

tcpip_init(NULL,NULL);
IP4_ADDR(&gw, 192,168,0,1);
IP4_ADDR(&ipaddr, 192,168,0,174);
IP4_ADDR(&netmask, 255,255,255,0);

netif_add(&rtl8019_netif,&ipaddr,&netmask,&gw,NULL,ethernetif_init,tcpip_input);
netif_set_default(&rtl8019_netif);
netif_set_up(&rtl8019_netif);
}
体系ping测验成功如图4.5-1 ping测验：

图4.5-1 ping测验

4.6 规划并完结简略的WEB服务器

HTTP是一个依据TCP/IP，归于运用层的面向对象的协议，咱们其简捷、快速的方法，适用于分布式超媒体信息体系。
经过浏览器拜访一个WEB服务器时，其实便是运用HTTP 协议向服务器发送web页面恳求，WEB服务器接纳到该恳求后，回来应对信息和浏览器恳求的网页内容。
咱们以一个最简略的比如阐明一下HTTP协议：
浏览器发送的规范恳求是这样的：
1. GET /index.html HTTP/1.1
2. Accept: text/html
3. Accept-Language: zh-cn
4. User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)
5. Connection: Keep-Alive
上面的恳求意义：
1. 阐明我需求index.html这个网页内容，运用的HTTP协议版本是1.1
2. 我能够接纳的文件类型是text/html
3. 我能够接纳的言语是中文
4. 浏览器的类型和版本号
5. 需求坚持长衔接。
服务器的回复信息是这样的：
1. HTTP/1.1 200 OK
2. Date: Sat, 4 Apr 2015 18:54:17 GMT
3. Server: microHttp/1.0 Zlgmcu Corporation
4. Accept-Ranges: bytes
5. Connection: Keep-Close
6. Content-Type: text/html; charset=gb2312
服务器回复的信息意义：
1. 服务器回来浏览器拜访的页面存在。
2. 该呼应头标明服务器支撑Range恳求,以及服务器所支撑的单位是字节(这也是仅有可用的单位)。
3. 封闭衔接
4. 服务器回来的文件类型为text/html，文件编码为gb2312。
依据上述HTTP协议原理，咱们能够规划一个简略的WEB服务器，有浏览器拜访时WEB服务器回来固定的页面。
在浏览器中输入开发板的IP地址：192.168.0.174
页面显现如图4.6-1 简略WEB服务器：

浏览器默许拜访端口是80，咱们开发板运用lwip供给的socket编程接口编程完结监听80端口，有浏览器拜访开发板的80端口，开发板向浏览器回来指定WEB页面。
完结代码如下：
void lwip_demo(void *pdata)
{
struct netconn *conn,*newconn;
lwip_init_task();

conn=netconn_new(NETCONN_TCP);
netconn_bind(conn,NULL,80);
netconn_listen(conn);

while(1)
{
newconn=netconn_accept(conn);
if(newconn!=NULL)
{
struct netbuf *inbuf;
char *dataptr;
u16_t size;
inbuf = netconn_recv(newconn);
if(inbuf!=NULL)
{
//测验事例
netbuf_data(inbuf,(void **)&dataptr,&size);
netconn_write(newconn,htmldata,sizeof(htmldata), NETCONN_NOCOPY);
netbuf_delete(inbuf);
}
netconn_close(newconn);
netconn_delete(newconn);
}
}
}

网页内容：
const unsigned char htmldata[]={
“HTTP/1.1 200 OK\r\n”
“Date: Sat, 4 Apr 2015 18:54:17 GMT\r\n”
“Server: microHttp/1.0 Zlgmcu Corporation\r\n”
“Accept-Ranges: bytes\r\n”
“Connection: Keep-Close\r\n”
“Content-Type: text/html; charset=gb2312\r\n”
“\r\n”
“\r\n”
“\r\n”
“\r\n”
“\r\n”
“

HELLO WELCOME TO LWIP WEB sever

硬件渠道：ARM

软件渠道：UCOS Lwip

Design by ***