EEPW论坛

STM32F103ZE uIP DM9051 Porting Guide

1.前言 1-1网卡芯片介绍

DM9051NP SPI接口网卡芯片是为了方便MCU单片机系统进行以太网通信而开发出的解决方案。DM9051NP芯片是带有行业标准串列外设接口（Serial Peripheral Interface，SPI）的独立以太网控制器。DM9051NP符合IEEE 802.3 规范，它还支持以DMA 模式來传输，以实现资料传送快速。DM9051NP通过1个中断引脚和SPI接口來进行与主控制器/MCU单片机的通信，资料传输规格为10/100 M。

•Package:32支接脚封装,QFN.

•IEEE 802.3az Energy Efficient Ethernet (EEE)

•Built-in integrated 3.3V to 1.8V regulator

•远程唤醒 (WOL)

•并行线/交叉线自动切换 (HP Auto-MDIX)

•Support 光口界面

•具有16KB SRAM静态随机存取记忆

•EMI (Class B) and HBM ESD Rating 8KV

• 工业温度规范: –40℃ to +85℃

• 功率：（100/10 M） => 429/561 mW

• 连续工作温度<60℃

【资料网盘链接】：http://pan.baidu.com/s/1jGB5Enk

1. DM9051NP SPI介面网卡介紹.pdf

2. DM9051NP datasheet.pdf

1-2工程代码&demo原理图

1. stm32_dm9051_uIP_SPIDMA.rar

2. DM9051_demo v2.1.pdf

目錄

1.前言 1

1-1网卡芯片介绍 1

1-2工程代码&demo原理图 1

2.搭建实验环境 3

3.硬件和软件说明 4

3-1 硬件环境 4

3-2 SPI配置 5

3-2-1. 接线部分 5

3-2-2. 软件配置部分 5

4.网卡驱动 11

4-1 网卡介绍 11

4-2 Read/Write Register 11

4-3 Read/Write Memory 13

4-3 18

4-4 DM9051 Received Packet 18

4-5 DM9051 Transmitted Packet 21

5.uIP基本结构与配置 23

5-1 首先介绍下uIP协议部分 23

5-2 uIP基本结构 25

5-3 uIP配置部分 29

5-3-1. IP地址配置 29

5-3-1. MAC地址配置 29

5-4 uip-conf.h部分 30

5-5一个简单有效的Clock Tick 31

6.案例——最简单的TCP echo程序 33

7.web页面控制 35

8.测试结果 42

9.移植相关 45

2.搭建实验环境

先讲一下如何搭建实验环境。我们STM32F103ZET6+DM9051作为一个网络终端通过网线跟PC直连（DM9051支持自动翻转功能(Auto-MDIX)，不用区分双绞线并行线）。例如调试PC机的IP地址如下图所示。

图1 PC机IP地址

路由器的IP地址为192.168.1.1。那么开发板的IP地址可以设定为 192.168.1.2到192.168.1.255。在这里，我们把开发板IP设为192.168.1.51。

3.硬件和软件说明 3-1 硬件环境

【百为开发板】

百为开发板上外接DM9051NP模块，DM9051NP通过SPI接口控制内部寄存器，并有中断输出接口。STM32通过SPI1和DM9051NP相连。具体接口如下：

	DM9051	STM32
SPI_CS(Chip_Select)	Pin01	Pin26(PC0)
SPI_MOSI	Pin03	Pin43(PA7)
SPI_MISO	Pin05	Pin42(PA6)
CPI_CLK	Pin07	Pin41(PA5)
Interrpt	Pin02	Pin97(PC7)

由于SPI上同时挂载其他SPI从设备，所有初始化的过程中需要通过操作CS端口禁止其他SPI从设备。CS片选将DM9051NP相连拉低，其他从设备拉高即可。

图二三：物理连接图

3-2 SPI配置 3-2-1. 接线部分

SPI信号线说明,通常SPI通过4个引脚与外部器件相连：

1. MISO : 主设备输入/从设备输出引脚。该引脚在从模式下发送数据，在主模式下接收数据。

2. MOSI : 主设备输出/从设备输入引脚。该引脚在主模式下发送数据，在从模式下接收数据。

3. SCK : 串口时钟，作为主设备的输出，从设备的输入

4. NSS : 从设备选择。这是一个可选的引脚，用来选择主/从设备。它的功能是用来作为“片选引脚”，让主设备可以单独地与特定从设备通讯，避免数据线上的冲突。

3-2-2. 软件配置部分

1. 首先开启SPI 1的时钟

2. 配置SPI 1 GPIO PIN，使用的pin還有SPI接線參考3-1。

3. 配置DMA，简单介紹一下:

(1). DMA是AMBA的先进高性能总线(AHB)上的设备，它有2个AHB端口：一个是从端口，用于配置DMA，另一个是主端口，使得DMA可以在不同的从设备之间传输数据。

(2). DMA的作用是在没有Cortex-M3核心的干预下，在后台完成数据传输。在传输数据的过程中，主处理器可以执行其它任务，只有在整个数据块传输结束后，需要处理这些数据时才会中断主处理器的操作。它可以在对系统性能产生较小影响的情况下，实现大量数据的传输。

4. SPI_DMA的通信过程

(1). 设置外设地址

(2). 设置存储器地址

(3). 设置传输数据量

(4). 设置通道的配置信息

(5). 使能DMA通道，启动传输

(6). 发送时，在每次TXE被设置为’1’时发出DMA请求，DMA控制器则写数据至SPI_DR寄存器，TXE标志因此而被清除。

(7). 接收时，在每次RXNE被设置为’1’时发出DMA请求，DMA控制器则从SPI_DR寄存器读出数据，RXNE标志因此而被清除。

DM9051 SPI1 DMA 配置如下:

void DM9051_Configuration(void)

{

SPI_InitTypeDef  SPI_InitStructure;

GPIO_InitTypeDef GPIO_InitStructure;

EXTI_InitTypeDef EXTI_InitStructure;

NVIC_InitTypeDef NVIC_InitStructure;

DMA_InitTypeDef    DMA_InitStructure;

/* Enable SPI1, DMA and GPIO clocks */

#ifdef SPI_DMA //Enable DMA

RCC_AHBPeriphClockCmd(SPI_MASTER_DMA_CLK, ENABLE); // if enable SPI_DMA  Configure DMA clock

#endif //SPI_DMA

RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOF, ENABLE);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE); // enable SPI1 clock

#ifdef DMA_INT

/* NVIC configuration */

NVIC_Configuration();

#endif //DMA_INT

/* Configure SPI1 pins: SCK, MISO and MOSI */

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init(GPIOA, &GPIO_InitStructure);

/* Configure I/O for DM9051 Chip select */

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_DM9051_CS;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

GPIO_Init(GPIO_DM9051_CS, &GPIO_InitStructure);

#if 1

/* Configure pins: SPI FLASH CS --------------------------------------------*/

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

GPIO_Init(GPIOB, &GPIO_InitStructure);

GPIO_SetBits(GPIOB, GPIO_Pin_2);

#endif

#if 1

/* Configure pins: LCD TOUCH CS --------------------------------------------*/

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

GPIO_Init(GPIOF, &GPIO_InitStructure);

GPIO_SetBits(GPIOF, GPIO_Pin_10);

#endif //0

/* Deselect the FLASH: Chip Select high */

//SPI_DM9051_CS_HIGH();

/* SPI1 configuration */

SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;

SPI_InitStructure.SPI_Mode = SPI_Mode_Master;

SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;

SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;

SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;

SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;

SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;

SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;

SPI_InitStructure.SPI_CRCPolynomial = 7;

SPI_Init(SPI1, &SPI_InitStructure);

#ifdef SPI_DMA

/* SPI_MASTER_Rx_DMA_Channel configuration ---------------------------------*/

DMA_DeInit(SPI_MASTER_Rx_DMA_Channel);

DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI_MASTER_DR_Base;

//DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SPI_MASTER_Buffer_Rx;

#ifdef uIP_NOOS

DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)uip_buf;

#endif

DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;

//DMA_InitStructure.DMA_BufferSize = BufferSize; //RX length

DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;

DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;

DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;

DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;

DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;

DMA_InitStructure.DMA_Priority = DMA_Priority_High;

DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;

DMA_Init(SPI_MASTER_Rx_DMA_Channel, &DMA_InitStructure);

/* SPI_MASTER_Tx_DMA_Channel configuration ---------------------------------*/

DMA_DeInit(SPI_MASTER_Tx_DMA_Channel);

DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI_MASTER_DR_Base;

//DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SPI_MASTER_Buffer_Tx;

#ifdef uIP_NOOS

DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)uip_buf;

#endif

DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;

DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;

DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;

DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;

DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;

DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;

DMA_InitStructure.DMA_Priority = DMA_Priority_High;

DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;

DMA_Init(SPI_MASTER_Tx_DMA_Channel, &DMA_InitStructure);

#ifdef DMA_INT

/* Enable DMA1 Channel2,3 Transfer Complete interrupt */

DMA_ITConfig(SPI_MASTER_Rx_DMA_Channel, DMA_IT_TC, ENABLE);

DMA_ITConfig(SPI_MASTER_Tx_DMA_Channel, DMA_IT_TC, ENABLE);

#endif //DMA_INT

//DMA_Cmd(SPI_MASTER_Rx_DMA_Channel, ENABLE);

//DMA_Cmd(SPI_MASTER_Tx_DMA_Channel, ENABLE);

#endif //SPI_DMA

/* Enable SPI1  */

SPI_Cmd(SPI1, ENABLE);

#ifdef DM9051_INT

/* configure PC7 as external interrupt */

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;

GPIO_Init(GPIOC, &GPIO_InitStructure);

/* Connect DM9051 EXTI Line to GPIOC Pin 7 */

GPIO_EXTILineConfig(GPIO_PortSourceGPIOC, GPIO_PinSource7);

/* Configure DM9051 EXTI Line to generate an interrupt on falling edge */

EXTI_InitStructure.EXTI_Line = EXTI_Line7;

EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;

EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;

EXTI_InitStructure.EXTI_LineCmd = ENABLE;

EXTI_Init(&EXTI_InitStructure);

/* Clear DM9051 EXTI line pending bit */

EXTI_ClearITPendingBit(EXTI_Line7);

/* Enable the EXTI7 Interrupt */

NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;

NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

NVIC_Init(&NVIC_InitStructure);

#endif //DM9051_INT

}

4.网卡驱动 4-1 网卡介绍

网卡采用DAVICOM  DM9051NP，DM9051相关特性與介紹可参考DM9051NP SPI网卡介紹，在上一章節介紹如何配置STM32 SPI & DMA，在配置完成後，需配置DM9051透過SPI介面送收Date，相关代码如下:

static __inline u8 SPI_DM9051_SendByte(u8 byte)

{

/* Loop while DR register in not emplty */

while (SPI_I2S_GetFlagStatus(DM9051_SPI, SPI_I2S_FLAG_TXE) == 0);

/* Send byte through the SPI1 peripheral */

SPI_I2S_SendData(DM9051_SPI, byte);

/* Wait to receive a byte */

SPI_I2S_GetFlagStatus(DM9051_SPI, SPI_I2S_FLAG_RXNE);

/* Return the byte read from the SPI bus */

return SPI_I2S_ReceiveData(DM9051_SPI);

}

4-2 Read/Write Register

在上一章配置好SPI read/write data function後，在此章節開始介紹如何透過SPI 來讀寫DM9051 Register & Memory，介紹如下:

A. 首先介紹Read Register，流程如下:

1. Reset CS(Chip Select) , GPIO pin pull low (Falling edge)

2. SPI send MOSI Reg Offset command.

3. SPI send 0x0 ceate a clock for Slave send data .

4. Set CS(Chip Select) GPIO pin pull High.

5. return rx data

相关代码參考如下:

static u8 DM9051_Read_Reg(u8 Reg_Off)

{

u8 spi_data;

SPI_DM9051_CS_LOW(); //讀取之前先將 Chip Select pull low

/* SPI transfer DM9051 Read-Command and Reg. offset. */

SPI_DM9051_SendByte(Reg_Off); //Read command + Register offset address

spi_data = SPI_DM9051_SendByte(0x0); //Dummy for read register value.

SPI_DM9051_CS_HIGH();//讀取完後再把chip Select  pull High

return spi_data;//返回Data

}

B. 再來介紹Write Register 流程部分，如下:

1. Reset CS(Chip Select) ,GPIOC PIN pull low.

2. SPI send MOSI  Reg_Offset | 0x80(disable DM9051 interrupt) value.

3. SPI send MOSI spi_data value .

4. Set CS(Chip Select) GPIOC PIN to high.

相关代码參考如下:

static void DM9051_Write_Reg(u8 Reg_Off, u8 spi_data)

{

u8 cmdaddr;

cmdaddr = (Reg_Off | 0x80);

SPI_DM9051_CS_LOW();

/* SPI transfer DM9051 Read-Command and Reg. offset. */

SPI_DM9051_SendByte(cmdaddr); //Read command + Register offset address

SPI_DM9051_SendByte(spi_data); //

SPI_DM9051_CS_HIGH();

return;

}

4-3 Read/Write Memory

在上一章節介紹如何讀寫DM9051暫存器後，相信如何使用SPI讀寫有一定的了解了，在這章節將講解如何讀寫DM9051 Memory，先简单說明一下為何需要讀寫Memory，DM9051具有16K-byte SRAM這個特性，可以將要送收data暫存在SRAM，在透過SPI接口對DM9051下command將存放在Memory裡的data 搬出來，讀寫Memory相关流程與代码如下:

A. 首先Read Memory流程:

1. Reset GPIOPIN low。

2. Send SPI interrup SPI write buffer command(Read Memory Register = 0x72)。

3. 此部分可以設定單一使用SPI 或SPI + DMA mode兩種設定如下:

(1) 只使用SPI mode ，透過SPI interface RX Memory data讀取出來

放到buffer。

(2) 使用SPI DMA mode ，將data 丟到DMA CMAR 和 設定data length to CNDTR。

1. 啟用DMA Channel。

2. 啟用 SPI TX Request command 開始送收data。

3. Dummy TX 主要是產生一個SPI clock讓DM9051送Data給Master， 因為DM9051 Chip 沒有DMA功能，透過送一個SPI Clock來觸發SPI 接收RX Packet。

4. 判斷等待data 完全送完，等待data完全送完後清除DMA Channel 等待標記。

5. Set GPIO PIN to high。

6. 关閉DMA Channel。

相关代码參考如下:

static void DM9051_Read_Mem(u8* pu8data, u16 datalen)

{

#ifndef SPI_DMA

u32 i;

#endif //SPI_DMA

uint32_t mccr;

#ifdef DMA_INT

uint8_t err;

#endif //DMA_INT

// Read SPI_Data_Array back from the slave

u8 burstcmd = SPI_RD_BURST;

SPI_DM9051_CS_LOW();

SPI_DM9051_SendByte(burstcmd);

#ifndef SPI_DMA  //if no enable SPI DMA

for(i=0; i

pu8data[i] = SPI_DM9051_SendByte(0x0);

}

SPI_DM9051_CS_HIGH();

#else

RxComplete = 0;

((DMA_Channel_TypeDef *)SPI_MASTER_Rx_DMA_Channel)->CMAR = (uint32_t)pu8data;

((DMA_Channel_TypeDef *)SPI_MASTER_Rx_DMA_Channel)->CNDTR = (uint32_t)datalen;

DMA_Cmd(SPI_MASTER_Rx_DMA_Channel, ENABLE);

SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, ENABLE); //RX DMA request, start move data

/* Dummy TX to generate SPI clock for RX*/

mccr = ((DMA_Channel_TypeDef *)SPI_MASTER_Tx_DMA_Channel)->CCR; //Save DMA channel 3 configuration register

((DMA_Channel_TypeDef *)SPI_MASTER_Tx_DMA_Channel)->CCR = (mccr & 0xffffff31); // Peripheral & memory doesn't auto increment. Interrupt disable

((DMA_Channel_TypeDef *)SPI_MASTER_Tx_DMA_Channel)->CMAR = (uint32_t)pu8data;

((DMA_Channel_TypeDef *)SPI_MASTER_Tx_DMA_Channel)->CNDTR = (uint32_t)datalen;

DMA_ITConfig(DMA1_Channel3, DMA_IT_TC, DISABLE); //Diable Interrupt

DMA_Cmd(SPI_MASTER_Tx_DMA_Channel, ENABLE);

SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE); //TX DMA request, start move data

#ifdef DMA_INT

OSSemPend(DM9051_rxdma_flag, 0,&err);

#else

while(!DMA_GetFlagStatus(SPI_MASTER_Rx_DMA_FLAG));

while(!DMA_GetFlagStatus(SPI_MASTER_Tx_DMA_FLAG));

#endif //DMA_INT

DMA_ClearFlag(SPI_MASTER_Rx_DMA_FLAG);

DMA_ClearFlag(SPI_MASTER_Tx_DMA_FLAG);

DMA_Cmd(SPI_MASTER_Rx_DMA_Channel, DISABLE);

/* Restore Tx setting */

DMA_Cmd(SPI_MASTER_Tx_DMA_Channel, DISABLE);

((DMA_Channel_TypeDef *)SPI_MASTER_Tx_DMA_Channel)->CCR = mccr;

DMA_ITConfig(DMA1_Channel3, DMA_IT_TC, ENABLE);

#endif //SPI_DMA

SPI_DM9051_CS_HIGH();

}

B. Write Memory流程:

1. Reset GPIO PIN to low。

2. Send SPI interface write memory buffer 。

3. 判斷使用SPI mode或SPI DMA mode。

4. 此部分可以設定單一使用SPI 或SPI + DMA mode兩種設定如下:

(1) 假設只使用SPI mode ，透過SPI interface send TX Packet to FIFO。

(2) 使用SPI DMA mode ，將data 丟到DMA CMAR和 設定data length to CNDTR。

a. 啟用DMA Channel。

b. 啟用 SPI TX Request Channel send packet。

c. 判斷等待data 完全送完，等待data完全送完後清除DMA Channel 的等待標記。

d. Set GPIO PIN to high。

e. 关閉DMA Channel。

相关代码參考如下:

static void DM9051_Write_Mem(u8* pu8data, u16 datalen)

{

#ifndef SPI_DMA

uint32_t i;

#endif //SPI_DMA

#ifdef DMA_INT

uint8_t err;

#endif //DMA_INT

/* Send the array to the slave */

u8 burstcmd = SPI_WR_BURST;

SPI_DM9051_CS_LOW();

SPI_DM9051_SendByte(burstcmd);

#ifndef SPI_DMA

for(i=0; i< datalen; i++) {

SPI_DM9051_SendByte(pu8data[i]);

}

SPI_DM9051_CS_HIGH();

#else

TxComplete = 0;

((DMA_Channel_TypeDef *)SPI_MASTER_Tx_DMA_Channel)->CMAR = (uint32_t)pu8data;

((DMA_Channel_TypeDef *)SPI_MASTER_Tx_DMA_Channel)->CNDTR = (uint32_t)datalen;

DMA_Cmd(SPI_MASTER_Tx_DMA_Channel, ENABLE);

SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE); //TX DMA request, start move data

#ifdef DMA_INT

OSSemPend(DM9051_txdma_flag, 0,&err);

#else

while(!DMA_GetFlagStatus(SPI_MASTER_Tx_DMA_FLAG));

#endif //DMA_INT

DMA_ClearFlag(SPI_MASTER_Tx_DMA_FLAG);

DMA_Cmd(SPI_MASTER_Tx_DMA_Channel, DISABLE);

#endif //SPI_DMA

SPI_DM9051_CS_HIGH();

}

以上都完成後，接下來就是DM9051_Init部份了，此部副可直接參考project 裡的Driver 裡面有相关配置。

如何使用DM9051，虽然DM9051使用复杂但是深入理解两点即可，第一点如何通过SPI发送命令和数据；第二点理解DM9051的缓冲区，在发送以太网和接受以太网数据报的过程中，DM9051会帮助用户做些额外的工作，例如发送时自动填充SFD，在读取接收缓冲区数据时会包含若干状态信息，包括数据报长度和CRC校验结果等。

4-3 4-4 DM9051 Received Packet

在上一章节介绍完read / write memory后，在这我们开始讲解DM9051是如何 送收packet ，首先先说明 RX packet 的流程，RX的部分最主要的是会将收进来的Date 返回在uip_len。

主要流程:

1.首先判断 DM9051 MRCMDX register 是不是为0或1，假如不为0或1则重置设备。

2.计算FIFO pointer，判断是否超过 0x3fff ，则需回归绕到 0x0c00 起始位置

3.将收到的packet返回rx_status和rx_len，再将rx_len丢到uip_buf，完成后继续判断rx_status 有无错误，没有的话的就返回rx_len。

相关代码参考如下:

uint16_t DM9051_rx(void)

{

uint8_t rxbyte;

uint16_t calc_MRR;

uint16_t rx_len = 0;

/* Check packet ready or not                                                                              */

rxbyte = DM9051_Read_Reg(DM9051_MRCMDX);

rxbyte = DM9051_Read_Reg(DM9051_MRCMDX);

/* if rxbyte != 1 or 0 reset device */

if ((rxbyte != 1) && (rxbyte != 0))

{

printf("rxbyte = %02X.\r\n", rxbyte);

DM9051_TRACE2("DM9051 rx: rx error, stop device \r\n");

/* Reset RX FIFO pointer */

DM9051_Write_Reg(DM9051_RCR, RCR_DEFAULT); //RX disable

DM9051_Write_Reg(DM9051_MPCR, 0x01); //Reset RX FIFO pointer

_DM9051_Delay(2);

DM9051_Write_Reg(DM9051_RCR, (RCR_DEFAULT | RCR_RXEN)); //RX Enable

/* restore receive interrupt                                                                            */

DM9051_device.imr_all |= IMR_PRM;

//DM9051_device.imr_all = IMR_DEFAULT;

DM9051_Write_Reg(DM9051_IMR, DM9051_device.imr_all);

return 0;

}

if (rxbyte)

{

uint16_t rx_status;

//uint16_t* data = 0;

uint8_t ReceiveData[4];

#ifdef FifoPointCheck

calc_MRR = (DM9051_Read_Reg(DM9051_MRRH) << 8) + DM9051_Read_Reg(DM9051_MRRL); //Save RX SRAM pointer

#endif //FifoPointCheck

DM9051_Read_Reg(DM9051_MRCMDX); //dummy read

DM9051_Read_Mem(ReceiveData, 4);

rx_status = ReceiveData[0] + (ReceiveData[1] << 8);

rx_len = ReceiveData[2] + (ReceiveData[3] << 8);

DM9051_Read_Mem((u8_t *)uip_buf, rx_len);

#ifdef FifoPointCheck

/* if over 0x3fff, return 0x0c00 */

calc_MRR += (rx_len + 4);

if(calc_MRR > 0x3fff) calc_MRR -= 0x3400;

if(calc_MRR != ((DM9051_Read_Reg(DM9051_MRRH) << 8) + DM9051_Read_Reg(DM9051_MRRL)))

{

printf("DM9K MRR Error!!\r\n");

printf("Predicut RX Read pointer = 0x%X, Current pointer = 0x%X\r\n", calc_MRR, ((DM9051_Read_Reg(DM9051_MRRH) << 8) + DM9051_Read_Reg(DM9051_MRRL)));

/* if pointer error, move pointer to next packet header */

DM9051_Write_Reg(DM9051_MRRH, (calc_MRR >> 8) & 0xff);

DM9051_Write_Reg(DM9051_MRRL, calc_MRR & 0xff);

}

#endif

if ((rx_status & 0xbf00) || (rx_len < 0x40) || (rx_len > DM9051_PKT_MAX) )

{

DM9051_TRACE2("rx error: status %04x, rx_len: %d \r\n", rx_status, rx_len);

if (rx_status & 0x100)

{

DM9051_TRACE2("rx fifo error \r\n");

}

if (rx_status & 0x200)

{

DM9051_TRACE2("rx crc error \r\n");

}

if (rx_status & 0x8000)

{

DM9051_TRACE2("rx length error \r\n");

}

if (rx_len > DM9051_PKT_MAX)

{

DM9051_TRACE2("rx length too big \r\n");

/* RESET device                                                                                     */

//_DM9051_WriteReg(DM9051_NCR, NCR_RST);

//_DM9051_Delay_ms(5);

}

}

}

return rx_len;

}

4-5 DM9051 Transmitted Packet

讲解完RX后，接著说明 DM9051 TX流程:

1.等待DM9051 TX Control Register Ready

2.计算FIFO Pointer，若是超过 0x0bff ，则需回归绕到 0x0000 起始位置

3.写入data 至 FIFO Poniter

4.送出data ，在完成后清除 TX request

5.判断FIFO Pointer有无乱掉，有的话往前移8 bit

相关代码参考如下:

u32 DM9051_tx(void)

{

uint16_t calc_MWR;

uint16_t SendLength;

while(DM9051_Read_Reg(DM9051_TCR) & DM9051_TCR_SET)

{

_DM9051_Delay(5);

}

#ifdef FifoPointCheck

/* 計算下一個傳送的指針位 , 若接收長度為奇數，需加一對齊偶字節 */

/* 若是超過 0x0bff ，則需回歸繞到 0x0000 起始位置 */

calc_MWR = (DM9051_Read_Reg(DM9051_MWRH) << 8) + DM9051_Read_Reg(DM9051_MWRL);

calc_MWR += SendLength;

//printf("calc_MWR = 0x%X\r\n", calc_MWR);

//if(SendLength & 0x01) calc_MWR++;

if(calc_MWR > 0x0bff) calc_MWR -= 0x0c00;

#endif

/* Move data to DM9051 TX RAM                                                                             */

//_DM9051_WriteRegAddr(DM9051_MWCMD);

//Write data to FIFO

DM9051_Write_Reg(DM9051_TXPLL, uip_len & 0xff);

DM9051_Write_Reg(DM9051_TXPLH, (uip_len >> 8) & 0xff);

DM9051_Write_Mem((u8_t*)uip_buf, SendLength);

#if 0

printf("Tx Read Pointer H = 0x%02X.\r\n", DM9051_Read_Reg(DM9051_TRPAH));

printf("Tx Read Pointer L = 0x%02X.\r\n", DM9051_Read_Reg(DM9051_TRPAL));

printf("DM9051_MWRH H = 0x%02X.\r\n", DM9051_Read_Reg(DM9051_MWRH));

printf("DM9051_MWRL L = 0x%02X.\r\n", DM9051_Read_Reg(DM9051_MWRL));

#endif  //0

//Write data to FIFO

DM9051_Write_Reg(DM9051_TXPLL, q->tot_len & 0xff);

DM9051_Write_Reg(DM9051_TXPLH, (q->tot_len >> 8) & 0xff);

DM9051_Write_Mem((u8_t*)q->payload, q->tot_len);

/* Issue TX polling command                                                                             */

DM9051_Write_Reg(DM9051_TCR, TCR_TXREQ);    /* Cleared after TX complete */

#ifdef FifoPointCheck

if(calc_MWR != ((DM9051_Read_Reg(DM9051_MWRH) << 8) + DM9051_Read_Reg(DM9051_MWRL)))

{

printf("DM9K MWR Error!! calc_MWR = 0x%X, SendLength = 0x%x\r\n", calc_MWR, SendLength);

printf("MWRH = 0x%X, MWRL = 0x%X\r\n", DM9051_Read_Reg(DM9051_MWRH), DM9051_Read_Reg(DM9051_MWRL));

/*Ι͏̼ѷƘ࠹Ҏ̼ѷҾɬŕŀΓׇѥƝʺƝYǬ٭  */

DM9051_Write_Reg(DM9051_MWRH, (calc_MWR >> 8) & 0xff);

DM9051_Write_Reg(DM9051_MWRL, calc_MWR & 0xff);

}

#endif //FifoPointCheck

return 0;

}

5.uIP基本结构与配置 5-1 首先介绍下uIP协议部分

uIP协议栈提供了我们很多接口函数，这些函数在 uip.h 中定义，为了减少函数调用造成的额外支出，大部分接口函数以宏命令实现的，uIP提供的接口函数有：

1. 初始化uIP协定栈：uip_init()

2．处理输入包：uip_input()

3．处理周期计时事件：uip_periodic()

4．开始监听端口：uip_listen()

5．连接到远程主机：uip_connect()

6．接收到连接请求：uip_connected()

7．主动关闭连接：uip_close()

8．连接被关闭：uip_closed()

9．发出去的数据被应答：uip_acked()

10．在当前连接发送数据：uip_send()

11．在当前连接上收到新的数据：uip_newdata()

12．告诉对方要停止连接：uip_stop()

13．连接被意外终止：uip_aborted()

在使用uIP的时候，一般通过如下顺序：

(1). 实现接口函数（回调函数）UIP_APPCALL。

该函数是我们使用uIP最关键的部分，它是uIP和应用程序的接口，我们必须根据自己的需要，在该函数做各种处理，而做这些处理的触发条件，就是前面提到的uIP提供的那些接口函数，如uip_newdata、uip_acked、uip_closed等等。另外，如果是UDP，那么还需要实现UIP_UDP_APPCALL回调函数。

(2). 调用tapdev_init函数，先初始化网卡。

此步先初始化网卡，配置MAC地址、ethernet mode (10/100 rate )，为uIP和网络通信做好准备。

(3). 调用uip_init函数，初始化uIP协定栈。

此步主要用于uip自身的初始化，我们直接调用就是。

(4). 等待DHCP 取得IP或设置固定IP地址、网关以及屏蔽等。

在初始化网卡完成后，DHCP会send discover packet 来取得IP，如果DHCP time out则会设定固定IP。这个和计算机上网差不多，只不过我们这里是通过uip_ipaddr、uip_sethostaddr、uip_setdraddr和uip_setnetmask等函数实现。

(5). 设置Applocation监听端口

uIP根据你设定的不同监听端口，实现不同的服务，比如我们实现Web Server就监听80端口(浏览器默认的端口是80端口)，凡是发现80端口的数据，都通过Web Server的APPCALL函数处理。根据自己的需要设置不同的监听端口。不过uIP有本地端口（lport）和远程端口（rport）之分，如果是做服务端，我们通过监听本地端口（lport）实现；如果是做客户端，则需要去连接远程端口（rport）。

(6). 处理uIP事件

最后，uIP通过uip_polling函数轮询处理uIP事件。该函数必须插入到用户的主循环里面（也就是必须每隔一定时间调用一次）。

5-2 uIP基本结构

uIP的代码编写需要遵守一定的结构，而且这种结构最好保持稳定（保持不变）。这个结构主要做以下几个部分任务。

1. 初始化系統、驱动、uIP protocol等

2. 取的DHCP IP，或固定IP

3. 获得以太网数据报

4. 处理ARP报文

5. 处理IP报文

6. 定期处理TCP和UDP连接

7. 定期更新ARP缓冲区

相关代码參考如下:

int main(void)

{

#ifndef __DHCPC_H__

uip_ipaddr_t ipaddr;

#endif //__DHCPC_H__

int i;

struct timer periodic_timer, arp_timer;

USART_Configuration();

/* Setting polling and arp timer */

timer_set(&periodic_timer, CLOCK_SECOND / 2); //500ms

timer_set(&arp_timer, CLOCK_SECOND * 10); // 10sec

/* Init ethernet driver */

tapdev_init();

/* Init uIP portocol */

uip_init();

uip_arp_init(); // Clear arp table.

#ifdef __DHCPC_H__

/* setup the dhcp renew timer the make the first request */

timer_set(&dhcp_timer, CLOCK_SECOND * 600);

/* Init Dhcpc */

dhcpc_init(&uip_ethaddr, 6);

//dhcpc_request();

#else

uip_ipaddr(ipaddr, 192,168,7,51); //Setting Host IP address

uip_sethostaddr(ipaddr);

uip_ipaddr(ipaddr, 192,168,7,1); //Setting Default Gateway

uip_setdraddr(ipaddr);

uip_ipaddr(ipaddr, 255,255,255,0); //Setting Network Mask

uip_setnetmask(ipaddr);

/* Display system information */

printf("\r\n---------------------------------------------\r\n");

printf("Network chip: DAVICOM DM9051 \r\n");

printf("MAC Address: %02X:%02X:%02X:%02X:%02X:%02X \r\n", uip_ethaddr.addr[0], uip_ethaddr.addr[1],

uip_ethaddr.addr[2], uip_ethaddr.addr[3], uip_ethaddr.addr[4], uip_ethaddr.addr[5]);

uip_gethostaddr(ipaddr); //get host IP

printf("Host IP Address: %d.%d.%d.%d \r\n", uip_ipaddr1(ipaddr), uip_ipaddr2(ipaddr), uip_ipaddr3(ipaddr), uip_ipaddr4(ipaddr));

uip_getnetmask(ipaddr); //get Get netmask

printf("Network Mask: %d.%d.%d.%d \r\n", uip_ipaddr1(ipaddr), uip_ipaddr2(ipaddr), uip_ipaddr3(ipaddr), uip_ipaddr4(ipaddr));

uip_getdraddr(ipaddr); // get getway

printf("Gateway IP Address: %d.%d.%d.%d \r\n", uip_ipaddr1(ipaddr), uip_ipaddr2(ipaddr), uip_ipaddr3(ipaddr), uip_ipaddr4(ipaddr));

printf("---------------------------------------------\r\n");

#endif //__DHCPC_H__

httpd_init(); //Init TCP task

/*Initial and start system tick time = 1ms */

SysTick_Config(SystemCoreClock / 1000);

while(1) {

uip_len = tapdev_read(); //reveive packet, and return uip_len

if(uip_len > 0) {

if(BUF->type == htons(UIP_ETHTYPE_IP)) {

//uip_arp_ipin();   //Removed by Spenser

uip_input(); // uip_process(UIP_DATA)

/* If the above function invocation resulted in data that

should be sent out on the network, the global variable

uip_len is set to a value > 0. */

if(uip_len > 0) {

uip_arp_out();

tapdev_send();

}

} else if(BUF->type == htons(UIP_ETHTYPE_ARP)) {

uip_arp_arpin();

/* If the above function invocation resulted in data that

should be sent out on the network, the global variable

uip_len is set to a value > 0. */

if(uip_len > 0) {

tapdev_send();

}

}

} else if(timer_expired(&periodic_timer)) {

timer_reset(&periodic_timer);

for(i = 0; i < UIP_CONNS; i++) {

uip_periodic(i);

/* If the above function invocation resulted in data that

should be sent out on the network, the global variable

uip_len is set to a value > 0. */

if(uip_len > 0) {

uip_arp_out();

tapdev_send();

}

}

#if UIP_UDP

for(i = 0; i < UIP_UDP_CONNS; i++) {

uip_udp_periodic(i);

/* If the above function invocation resulted in data that

should be sent out on the network, the global variable

uip_len is set to a value > 0. */

if(uip_len > 0) {

uip_arp_out();

tapdev_send();

}

}

#endif /* UIP_UDP */

/* Call the ARP timer function every 10 seconds. */

if(timer_expired(&arp_timer)) {

timer_reset(&arp_timer);

uip_arp_timer();

}

}

#ifdef __DHCPC_H__

else if (timer_expired(&dhcp_timer)) {

// for now turn off the led when we start the dhcp process

dhcpc_renew();

timer_reset(&dhcp_timer);

}

#endif //__DHCPC_H__

}

}

简单說明一下uip buffer和 调试驱动 :

1.#define BUF ((struct uip_eth_hdr *)&uip_buf[0])

指向uIP缓冲区，强制类型转化为uip_eth_hdr结构体，uip_eth_hdr即为以太网首部结构，6字节目标MAC地址 6字节源MAC地址 2字节类型。

2. tapdev_init();tapdev_read();tapdev_send();

三个函数为以太网操作函数，只有tapdev_read有返回值，其他函数即无输入参数也无返回参数。这三个函数便是DM9051操作的三个封装，DM9051发送或接收直接操作uIP的两个全局变量uip_buf和uip_len。tapdev.c具体代码如下：

/* Init DM9051 */

void tapdev_init(void)

{

DM9051_init();

}

/* received data return uip_len */

unsigned int tapdev_read(void)

{

return DM9051_rx();

}

/* send data */

void tapdev_send(void)

{

DM9051_tx();

}

5-3 uIP配置部分 5-3-1. IP地址配置

IP地址设置包括，本地IP地址，网关地址和子网掩码。可参考6-2。

5-3-1. MAC地址配置

MAC的地址较为特殊，由于DM9051本身没有唯一的EUI-48（俗称MAC地址）地址，所以EUI-48地址需要手动配置。该地址不但应用于DM9051也应用于uIP。相关设定MAC Address代码如下介绍:

首先在uip-conf.h，定义emacETHADDR 设定MAC address:

#define emacETHADDR0   0x00

#define emacETHADDR1   0x60

#define emacETHADDR2   0x6e

#define emacETHADDR3   0x90

#define emacETHADDR4   0x51

#define emacETHADDR5   0x02

#if UIP_FIXEDETHADDR // if open UIP_FIXEDETHADDR

const struct uip_eth_addr uip_ethaddr = {{emacETHADDR0,

emacETHADDR1,

emacETHADDR2,

emacETHADDR3,

emacETHADDR4,

emacETHADDR5}};

#else

struct uip_eth_addr uip_ethaddr = {{0,0x6A,0x60,0x90,0x51,0}};

#endif

另外补充：DM9051 默认先从EEPROM读取MAC地址，如无挂载EEPROM，则通过软件设定。IP地址也是先透过DHCP获取，如获取不到则采取代码设定固定值。

5-4 uip-conf.h部分

uip-conf部分说明三点

1. 如果不熟悉请保留默认参数，例如UIP_CONF_MAX_CONNECTIONS等

2. 如果设置UIP_CONF_LOGGING为1，请添加void uip_log(char *m){}

3. 必须包含用户任务头文件，且放在该头文件的最后。例如添加#include "example1.h"。这样做的主要目的是定义uip_tcp_appstate_t和UIP_APPCALL两个关键参数。具体代码如下:

#ifndef __UIP_CONF_H

#define __UIP_CONF_H

#include 

typedef uint8_t u8_t;

typedef uint16_t u16_t;

typedef unsigned short uip_stats_t;

/* 最大TCP连接数 */

#define UIP_CONF_MAX_CONNECTIONS 10

/* 最大端口监听数 */

#define UIP_CONF_MAX_LISTENPORTS 10

/* uIP 缓存大小*/

#define UIP_CONF_BUFFER_SIZE 1500

/* CPU字节顺序 */

#define UIP_CONF_BYTE_ORDER UIP_LITTLE_ENDIAN

/* 日志开关 */

#define UIP_CONF_LOGGING 1

/* UDP支援开关*/

#define UIP_CONF_UDP 0

/* UDP校验和开关 */

#define UIP_CONF_UDP_CHECKSUMS 1

/* uIP统计开关 */

#define UIP_CONF_STATISTICS 1

// 加入用户任务头文件，请修改

#include "example1.h"

#endif

5-5一个简单有效的Clock Tick

uIP协议栈处理过程需要一个定时配合，该定时器实际为一个软件定时器，定时器说明uIP处理若干周期性任务，例如处理TCP连接重传，定时更新ARP缓冲表等。设计定时器的方法很多，在这里推荐uIP原作者的timer模块。

timer模块的原理类似于MCU硬件中的比较匹配原理，timer模块中有一个全部变量counter，每次MCU发生某个定时器中断时累加1，如果某个任务需要使用定时器服务，在该任务中声明一个timer(在该任务中为全局变量)，并记录此时的counter值。

判断溢出可查询当前的counter和被记录的counter的差值，如果差值超过间隔值那么软件定时器timer溢出（类似于发生比较匹配中断）。

软件定时器的主要作用有两个。第一，更新TCP或UDP连接，第二，更新ARP缓冲区(ARP表)。虽然uIP在功能上比LwIP简单的多，但是LwIP也有类似的部分(或者说完全一样)。详细代码修改clock-arch.c如下:

#include "clock-arch.h"

#include "stm32f10x.h"

extern __IO int32_t g_RunTime;

/*---------------------------------------------------------------------------*/

clock_time_t

clock_time(void)

{

return g_RunTime;

}

/*---------------------------------------------------------------------------*/

修改clock-arch.h如下

typedef int clock_time_t;

#define CLOCK_CONF_SECOND 100

作用是：clock_time 用于配置系统产生滴答的间隔，我的开发板系统时钟跑的是72MHz，即每隔720,000,000/100产生一次系统滴答，一个系统滴答是10ms, CLOCK_SECOND (这里定义为100) 个clock tick即为1S。

使用stm32 System Tick中断代码，stm32f10x_it.c修改如下：

__IO int32_t g_RunTime = 0;

void SysTick_Handler(void)

{

static uint8_t s_count = 0;

if (++s_count >= 10)

{

s_count = 0;

g_RunTime++;    /* every 10ms add 1 */

if (g_RunTime == 0x80000000)

{

g_RunTime = 0;

}

}

}

6.案例——最简单的TCP echo程序

先来一个最简单的TCP程序。uIP作为server，IP地址为192.168.1.15。PC机做client，IP地址为192.168.1.10X。

【1】在网络调试助手中，选择以太网通信种类为client(表示PC机为Client)，IP地址输入192.168.1.15，端口号输入1234。最后点击连接。

【2】在发送区域输入任意内容，点击发送数据。

【3】观察返回结果，是否和发送数据相同。

为了实现该功能新建example1.c和example1.两个文件。代码如下:

#include "example1.h"

#include "uip.h"

#include 

#include 

#include 

void example1_init(void)

{

uip_listen(HTONS(1234));

}

void example1_appcall(void)

{

if( uip_newdata() )

{

// 输出远程IP和端口号

printf("remote ip addr:%d.%d.%d.%d\r\n",

(uip_conn->ripaddr[0]) & 0X00ff,

(uip_conn->ripaddr[0]) >> 8,

(uip_conn->ripaddr[1]) & 0X00ff,

(uip_conn->ripaddr[1]) >> 8

);

printf("remote ip port:%d\r\n",HTONS(uip_conn->rport));

// TCP ECHO

uip_send(uip_appdata,uip_len);

}

}

图3 TCP Echo实验结果

代码做如下分析:

1. uip_listen(HTONS(1234));侦听1234端口，

2. uip_newdata()即查询uip_buf中是否有新数据，如果返回1的话，表示接收到新数据。

3. uip_send(uip_appdata,uip_len);uip_send为发送数据报函数

4. uip_appdata指向用户数据，所谓用户数据即TCP负载数据，例如网络调试助手发送XX，那么uip_appdata指向xukai871105.

5. uip_len为用户数据长度，若串口调试助手发送XX，那么uip_len为11。

7.web页面控制

1. 打开IE浏览器，地址栏输入DM9051的IP地址:

http://192.168.x.x/

回车后打开下面控制页面：

2. 网頁下可以看到MCU跟IP基本訊息(如:MAC、IP address)，最下面有LED Test，可通过网页控制STM32板上的LED灯。

LED Test說明，在按下 ON 的時候，GPIOF6 腳位LED 燈會亮，按下OFF後會滅掉，Flash 代表閃爍，會從GPIOF6 ~9 LED順序亮滅，网址列上會顯示LED1跟LED0，1代表亮，0但表滅，2代表閃爍。

3. 具体code如下介紹：

(1). 稍微介绍一下web相关，另外标出端口、IP、GPIO/LED的修改位置。

在void main()中，系統初始化完成後加入httpd_init(); 來初始化webserver port，預設web 用80 port。

(2). 在初始化完成後，在uip-conf.h最下面將#include "webserver.h"的注釋拿掉，這樣UIP_APPCALL 就能對應到 httpd_appcall。

(3). 首先我們先在main.c初始 LED燈GPIO PIN，代码如下:

void LedInit(void)

{

GPIO_InitTypeDef GPIO_InitStructure;

RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOF | RCC_APB2Periph_GPIOF, ENABLE);

/*初始化 GPIOF的 Pin_6为推挽输出*/

GPIO_InitStructure.GPIO_Pin=GPIO_Pin_6;

GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;

GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;

GPIO_Init(GPIOF,&GPIO_InitStructure);

/*初始化 GPIOF的 Pin_7为推挽输出*/

GPIO_InitStructure.GPIO_Pin=GPIO_Pin_7;

GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;

GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;

GPIO_Init(GPIOF,&GPIO_InitStructure);

/*初始化 GPIOF的 Pin_8为推挽输出*/

GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8;

GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;

GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;

GPIO_Init(GPIOF,&GPIO_InitStructure);

/*初始化 GPIOF的 Pin_9为推挽输出*/

GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9;

GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;

GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;

GPIO_Init(GPIOF,&GPIO_InitStructure);

}

初始化完成後，在webserver目錄下新增web_led.c和web_led.h檔，代码參考如下:

(1). 首先設定LED 亮滅delay 時間:

void Delay(uint32_t times)

{

while(times--)

{

uint32_t i;

for (i=0; i<0xffff; i++);

}

}

(2). 接下來設定LED 亮滅順序，我們使用ascii码來判斷亮滅，

void Set_LED_mode(char lkkcode)

{

//int i;

/* 0代表LED6滅, 1代表LED6亮, 2代表LED6~9依序閃爍 */

if(lkkcode == ('0'))

{

GPIO_ResetBits(GPIOF,GPIO_Pin_6);

}else if (lkkcode == '1'){

GPIO_SetBits(GPIOF,GPIO_Pin_6);

}else if(lkkcode == '2')

{

//for(i = 0 ; i< 30 ; ++i)

{

GPIO_SetBits(GPIOF,GPIO_Pin_6);

Delay(25);

GPIO_ResetBits(GPIOF,GPIO_Pin_6);

Delay(25);

GPIO_SetBits(GPIOF,GPIO_Pin_7);

Delay(25);

GPIO_ResetBits(GPIOF,GPIO_Pin_7);

Delay(25);

GPIO_SetBits(GPIOF,GPIO_Pin_8);

Delay(25);

GPIO_ResetBits(GPIOF,GPIO_Pin_8);

Delay(25);

GPIO_SetBits(GPIOF,GPIO_Pin_9);

Delay(25);

GPIO_ResetBits(GPIOF,GPIO_Pin_9);

Delay(25);

}

}

}

(3). 設定好初始化LED GPIO後，在网址列輸入IP後會顯預設的示网頁，网頁內容為html放在app/webserver/ httpd-fs目錄下，主要為index.html，如想要修改顯示使用者网頁有兩種方式:

(4). 修改代码參考如下:

1. 直接修改index.html。

2. 將使用者的html 放入httpd-fs目錄下，然後在handle_input修改

3. 判斷LED亮滅，s->inputbuf array中填入ascii码或其他使用者想實現的判斷，如s->inputbuf[3] = 'L','E','D'。

static PT_THREAD(handle_input(struct httpd_state *s))

{

PSOCK_BEGIN(&s->sin);

PSOCK_READTO(&s->sin, ISO_space);

if(strncmp(s->inputbuf, http_get, 4) != 0) {

PSOCK_CLOSE_EXIT(&s->sin);

}

PSOCK_READTO(&s->sin, ISO_space);

if(s->inputbuf[0] != ISO_slash) {

PSOCK_CLOSE_EXIT(&s->sin);

}

if(s->inputbuf[1] == ISO_space) {

//strncpy(s->filename, http_index_html, sizeof(s->filename)); //修改成想要顯示的html檔，如下:

strncpy(s->filename, http_webMain_html, sizeof(s->filename));

}

/* Control led , 0 = OFF, 1 = ON, 2 = Flash */

#if 1 //Joseph add

else if (s->inputbuf[3] == 'L','E','D' && ((s->inputbuf[4] == '0') ||

(s->inputbuf[4] == '1') || (s->inputbuf[4] == '2'))){

Set_LED_mode(s->inputbuf[4]);

s->inputbuf[4]= 0;

//strncpy(s->filename, "/home.html", 10);

strncpy(s->filename, http_webMain_html, sizeof(s->filename));

}

#endif

else {

s->inputbuf[PSOCK_DATALEN(&s->sin) - 1] = 0;

strncpy(s->filename, &s->inputbuf[0], sizeof(s->filename));

}

/*  httpd_log_file(uip_conn->ripaddr, s->filename);*/

s->state = STATE_OUTPUT;

while(1) {

PSOCK_READTO(&s->sin, ISO_nl);

if(strncmp(s->inputbuf, http_referer, 8) == 0) {

s->inputbuf[PSOCK_DATALEN(&s->sin) - 2] = 0;

/*      httpd_log(&s->inputbuf[9]);*/

}

}

PSOCK_END(&s->sin);

}

(5).上面介紹完网頁和控制LED燈後，接著說明如何在网頁上顯示目前的MAC、IP address等，在httpd-cgi.c檔下新增sys_ stats function，代码參考如下:

static unsigned short generate_sys_stats(void *arg)

{

struct httpd_state *s = (struct httpd_state *)arg;

return snprintf((char *)uip_appdata, UIP_APPDATA_SIZE,

"MAC Address :%02x:%02x:%02x:%02x:%02x:%02x\

IP Address : %d.%d.%d.%d\

Network Mask : %d.%d.%d.%d\

Getway : %d.%d.%d.%d\r\n",

/* MAC address */

(unsigned int)uip_ethaddr.addr[0], (unsigned int)uip_ethaddr.addr[1],

(unsigned int)uip_ethaddr.addr[2], (unsigned int)uip_ethaddr.addr[3],

(unsigned int)uip_ethaddr.addr[4], (unsigned int)uip_ethaddr.addr[5],

/* IP address */

(uip_hostaddr[0]&0xff), ((uip_hostaddr[0] >> 8)&0xff),

(uip_hostaddr[1]&0xff), ((uip_hostaddr[1] >> 8)&0xff),

/* network mask */

(uip_netmask[0]&0xff), ((uip_netmask[0] >> 8)&0xff),

(uip_netmask[1]&0xff), ((uip_netmask[1] >> 8)&0xff),

/* Getway address */

(uip_draddr[0]&0xff), ((uip_draddr[0] >> 8)&0xff),

(uip_draddr[1]&0xff), ((uip_draddr[1] >> 8)&0xff)

);

}

static PT_THREAD(sys_stats(struct httpd_state *s, char *ptr))

{

PSOCK_BEGIN(&s->sout);

//for(s->count = 0; s->count < UIP_CONNS; ++s->count) {

if((uip_conns[s->count].tcpstateflags & UIP_TS_MASK) != UIP_CLOSED) {

PSOCK_GENERATOR_SEND(&s->sout, generate_sys_stats, s);

}

//}

PSOCK_END(&s->sout);

8.测试结果

接上网线后：

首先设置PC端IP与DM9051 在同一段内；

1. 运行-cmd

输入 ping 192.168.x.x 测试是否能ping通；

输入 ping 192.168.x.x  -n 100 测试连通丢包率；ctrl+c停止；

2. 查看确认物理地址

输入 arp  -a 192.168.x.x 回车；显示物理地址。

3. 速率测试结果：

注：所用工具软件为：网络调试助手+IPOP。

A. 利用网络调试助手循环发送文档，让输出达到最大值从而测试DM9051的最大速率；

B. 由结果可以看出速率，而平均235Kb/s的速率算是比较稳定的了。

4. 使用iperf頻寬测试结果大約有8 . 5M多:

9.移植相关

移植第一步：实现在unix/tapdev.c里面的三个函数。首先是tapdev_init函数，该函数用于初始化网卡（也就是我们的DM9051），通过这个函数实现网卡初始化。其次，是tapdev_read函数，该函数用于从网卡读取一包数据，将读到的数据存放在uip_buf里面，数据长度返回给uip_len。最后，是tapdev_send函数，该函数用于向网卡发送一包数据，将全局缓存区uip_buf里面的数据发送出去（长度为uip_len）。其实这三个函数就是实现最底层的网卡操作。

第二步，因为uIP协议栈需要使用时钟，为TCP和ARP的定时器服务，因此我们需要STM32提供一个定时器做时钟，提供10ms计时（假设clock-arch.h里面的CLOCK_CONF_SECOND为100），通过clock-arch.c里面的clock_time函数返回给uIP使用。

第三步，配置uip-conf.h里面的宏定义选项。主要用于设置TCP最大连接数、TCP监听端口数、CPU大小端模式等，这个大家根据自己需要配置即可。

通过以上3步的修改，我们基本上就完成了uIP的移植。

1，写网卡驱动程序，与具体硬件相关。这一步比较费点时间，不过好在大部分网卡芯片的驱动程序都有代码借鉴或移植。驱动需要提供三个函数：

tapdev_init（）：网卡初始化函数，初始化网卡的工作模式。

tapdev_read(void)：读包函数。将网卡收到的数据放入全局缓存区uip_buf 中，返回包的长度，赋给uip_len。

void tapdev_send(void)：发包函数。将全局缓存区uip_buf 里的数据（长度放在uip_len 中）发送出去。

2.uipopt.h/uip-conf.h 是配置文件，用来设置本地的IP 地址、网关地址、MAC 地址、全局缓冲区的大小、支持的最大连接数、侦听数、ARP 表大小等。可以根据需要配置。

3.还需要更改些什么？

附上一个UIP移植连结：http://forum.eepw.com.cn/thread/262079/1/

正点原子移植连结：http://home.eeworld.com.cn/my/space-uid-73591-blogid-116863.html