Ethernet
Microcontroller
EPD Driver & SOC

Video Decoder
FAX/Modem
Medical & Apps

ETHERNET CONTROLLERS
PHY
SWITCH
USB TO ETHERNET

DM9051NP 乙太網芯片驅動源代碼介绍

一、DM9051NP 介紹

DM9051NP SPI接口以太网模块是联杰国际(DAVICOM)为了方便嵌入式ARM、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℃

二、驱动程序说明

1.DM9051的寄存器读写方式说明

由于DM9051NP以太网口芯片采用的是SPI串行接口模式，其对内部寄存器读写的规则是先发操作码bit 7 (set 0 or 1) + 寄存器地址<后7bit>，再发送欲操作数据(bit 0~8)。通过不同操作码来判别操作时读寄存器(缓存区)还是写寄存器(缓冲区)或是其它。

2.DM9051 模式设定说明:

(1)设定DM9051 PHY Mode，DM9051 支持以下 Speed 和全/半双工设定

・DM9051_AUTO Auto negotiation
・DM9051_10MHD 10MHz, Half duplex
・DM9051_10MFD 10MHz, Full duplex
・DM9051_100MHD 100MHz, Half duplex
・DM9051_100MFD 100MHz, Full duplex

enum DM9051_PHY_mode
{
	DM9051_10MHD   = 0,
	DM9051_100MHD  = 1,
	DM9051_10MFD   = 4,
	DM9051_100MFD  = 5,
	DM9051_10M     = 6,
	DM9051_AUTO    = 8,
	DM9051_1M_HPNA = 0x10
};

以上模式透过SPI写入Register，可参考DM9051 Driver。

(2)选择DM9051 Chip Type ，目前使用的 TYPE_DM9051

enum DM9051_TYPE
{
	TYPE_DM9000E,
	TYPE_DM9000A,
	TYPE_DM9000B,
	TYPE_DM9051
};

(3)在上述建立Mode 和 Tyep 表后，放入struct DM9051_eth，以便后续设定使用。

struct DM9051_eth
{
	/* 设定目前使用的网络芯片类型 */
	enum DM9051_TYPE type;
	/* 设定PHY使用的 Speed and Duplex */
	enum DM9051_PHY_mode mode;
	/* Interrupt Mask Resgister 设定值 */
	uint8_t  imr_all;
	/* packet I or II */
	uint8_t  packet_cnt; 
	/* queued packet (packet II)*/
	uint16_t queue_packet_len;	
	/* interface MAC address info. */
	uint8_t  dev_addr[6]; 
};
static struct DM9051_eth DM9051_device;

3.DM9051驱动程序说明

(1)MCU SPI Configure

如同上述介绍的DM9051NP以太网口芯片采用的是SPI串行接口模式，首先第一步先确认MCU有支持SPI，再来配置SPI Master的相关设定，在这以STM32F103ZE SPI1 设定为参考，其他MCU可直接参考MCU的SPI example 设定。

Source code :

void DM9051_SPI_Configuration(void)

{
	SPI_InitTypeDef  SPI_InitStructure;
	GPIO_InitTypeDef GPIO_InitStructure;
	EXTI_InitTypeDef EXTI_InitStructure;
	DMA_InitTypeDef  DMA_InitStructure;
	 /* 使能 SPI1 时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, Enable);

	/* 找出MCU SPI Pin，在这以配置 SPI1 pins为例: SCK, MISO and MOSI */
	GPIO_InitStructure.GPIO_Pin = DM9051_SPI_SCK_PIN | DM9051_SPI_MISO_PIN | DM9051_SPI_MOSI_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(DM9051_SPI_PIN_GROUP, &GPIO_InitStructure);

	/* Configure I/O for DM9051 Chip select */
	GPIO_InitStructure.GPIO_Pin = DM9051_SPI_CS_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_Init(DM9051_SPI_CS_GROUP, &GPIO_InitStructure);

	GPIO_SetBits(DM9051_SPI_PIN_GROUP, DM9051_SPI_SCK_PIN | DM9051_SPI_MISO_PIN | DM9051_SPI_MOSI_PIN);

	/* SPI1 为Master 相关设定参考 */
	/* 设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工 */
	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
	/* 设置SPI工作模式:设置为主SPI */
	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
	/* 设置SPI的数据大小:SPI发送接收8位帧结构 */
	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
	/* 选择了串行时钟的稳态:时钟拉低 */
	SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
	/* 资料捕获于第一个时钟沿 */
	SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
	/* NSS 信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制 */
	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
	/* 定义波特率预分频的值:波特率预分频值为2 */
	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
	/* 指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始 */
	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
	/* CRC值计算的多项式 */
	SPI_InitStructure.SPI_CRCPolynomial = 7;
	/* 根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器 */
	SPI_Init(DM9051_SPI, &SPI_InitStructure);

	/* 使能 DM9051_SPI  */
	SPI_Cmd(DM9051_SPI, ENABLE);
}

以上 STM32F103ZE SPI1 相关配置，需注意的设定如下:

/* 资料捕获于第一个时钟沿 */
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
/* NSS 信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制 */
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;

SPI 的Master、Slave 必须配置成相同的时序模式，此部分参考MCU SPI mode 和DM9051 SPI mode 相对应的设定。

(2) MCU SPI读写一字节程序和读写DM9051 Register & Memory 说明

a. 此程序可参考STM32 SPI example 或网络上搜寻相关写法参考

static const __inline uint8_t SPI_DM9051_SendByte(uint8_t byte)
{
	/* 检查指定的SPI标志位设置与否:发送缓存空 */
	while (SPI_I2S_GetFlagStatus(DM9051_SPI, SPI_I2S_FLAG_TXE) == 0);

	/* 通过外设SPIx 发送一个数据 */
	SPI_I2S_SendData(DM9051_SPI, byte);

	/* 判断接收是否完成 */
	while (SPI_I2S_GetFlagStatus(DM9051_SPI, SPI_I2S_FLAG_RXNE) == 0);

	/* 返回通过SPIx最近接收的数据 */
	return SPI_I2S_ReceiveData(DM9051_SPI);
}

在撰写完SPI读写一个字节程序后，即可撰写MCU 读写DM9051 Register和Memory function。

b. MCU读取DM9051 Register

uint8_t DM9051_Read_Reg(uint8_t Reg_Off)
{
	 uint8_t spi_data;

	 #ifdef DM9051_INT	
	 /* 关闭 MCU 所有Interrupt */
	 INT_ALL_DISABLE();
	 #endif //DM9051_INT

	 /* 使能 SPI CSS，SPI 开始送收*/
	 SPI_DM9051_CS_LOW();	

	 /* SPI transfer DM9051 Read-Command and Reg. offset. */
	 SPI_DM9051_SendByte(Reg_Off);	
	 /* Dummy for read register value. */
	 spi_data = SPI_DM9051_SendByte(0x0);

	 /* 禁止 SPI CSS，完成操作*/
	 SPI_DM9051_CS_HIGH();

	 #ifdef DM9051_INT		
	 /* 打开 MCU 所有Interrupt */	 
	 INT_ALL_ENABLE();
	 #endif // DM9051_INT	
	 return spi_data;
}

c. MCU写入DM9051 Register

 
void DM9051_Write_Reg(uint8_t Reg_Off, uint8_t spi_data)
{
	uint8_t cmdaddr;
	cmdaddr = (Reg_Off | 0x80);

	#ifdef DM9051_INT
	/* 关闭 MCU 所有Interrupt */
	INT_ALL_DISABLE();
	#endif //DM9051_INT	

	/* 使能 SPI CSS，SPI 开始送收*/
	SPI_DM9051_CS_LOW();

	/* SPI transfer DM9051 Read-Command and Reg. offset. */
	SPI_DM9051_SendByte(cmdaddr);

	/* SPI1 写操作数据 */
	SPI_DM9051_SendByte(spi_data);

	/* 禁止 SPI CSS，完成操作*/
	SPI_DM9051_CS_HIGH();

	#ifdef DM9051_INT
	/* 打开 MCU 所有Interrupt */
	INT_ALL_ENABLE();
	#endif //DM9051_INT

	return;
}

d. MCU 读取DM9051 Memory

void DM9051_Read_Mem(uint8_t* pu8data, uint16_t datalen)
{
	uint32_t i;
	uint8_t burstcmd = SPI_RD_BURST; // Read SPI_Data_Array back from the slave

	#ifdef DM9051_INT
	INT_ALL_DISABLE();
	#endif //DM9051_INT

	/* 使能 SPI CSS，SPI 开始送收*/
	SPI_DM9051_CS_LOW();
	/* 发送读取指令 */	
	SPI_DM9051_SendByte(burstcmd);
	/* 读取接收缓存数据 */
	for(i=0; i < datalen; i++) {
		pu8data[i] = SPI_DM9051_SendByte(0x0);
	}	
	/* 禁止 SPI CSS，完成操作*/	
	SPI_DM9051_CS_HIGH();	

	#ifdef DM9051_INT	
	INT_ALL_ENABLE();
	#endif //DM9051_INT
}

e. MCU 写入DM9051 Memory

void DM9051_Write_Mem(uint8_t* pu8data, uint16_t datalen)
{
	uint32_t i;	
	uint8_t burstcmd = SPI_WR_BURST; // Send the array to the slave

	#ifdef DM9051_INT
	INT_ALL_DISABLE();
	#endif // DM9051_INT	

	/* 使能 SPI CSS，SPI 开始送收*/
	SPI_DM9051_CS_LOW();
	/* 发送写入指令 */	
	SPI_DM9051_SendByte(burstcmd);
	/* 发送写入缓存资料 */	
	for(i=0; i< datalen; i++) {
		SPI_DM9051_SendByte(pu8data[i]);
	}
	/* 禁止 SPI CSS，完成操作*/
	SPI_DM9051_CS_HIGH();

	#ifdef DM9051_INT	
	INT_ALL_ENABLE();
	#endif //DM9051_INT
}

關閉

DM9051於STM32F103ZE平台uIP开发指导

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℃

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

2.搭建实验环境

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

(圖a)

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相连拉低，其他从设备拉高即可。

(圖b)

(圖c)

图b,c：物理连接图

3-2 SPI配置

3-2-1. 接线部分

(圖d)

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介面送收data，相關代碼如下:

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. 1. 啟用DMA Channel。
2. 2. 啟用 SPI TX Request command 開始送收data。
3. 3. Dummy TX 主要是產生一個SPI clock讓DM9051送Data給Master，因為DM9051 Chip 沒有DMA功能，透過送一個SPI Clock來觸發SPI 接收RX Packet。
4. 4. 判斷等待data 完全送完，等待data完全送完後清除DMA Channel 等待標記。
5. 5. Set GPIO PIN to high。
6. 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; iCMAR = (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兩種設定如下:

相關代碼參考如下:

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-4 DM9051 Received Packet

在上一章節介紹完read / write memory後，在這我們開始講解DM9051是如何送收封包packet ，首先先說明 RX packet 的流程，RX的部分最主要的是會將收進來的data 返回在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配置部分

1. IP地址配置

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

2. MAC地址配置

MAC的地址较为特殊，由于DM9051本身没有唯一的EUI-48（俗称MAC地址）地址，所以EUI-48地址需要手动配置。该地址不但应用于DM9051也应用于uIP。相关设定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);
    }
}

图e 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/

(圖f)

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

(圖g)

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代表閃爍。

(圖h)

(圖i)

具体code如下介紹：

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

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

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

(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停止；

(圖j)

2.查看确认物理地址

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

(圖k)

3.速率测试结果：

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

(圖l)

(圖m)

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

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

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

(圖n)

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的移植。

通过以上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移植供各位參考：

从零开始使用uIP

http://forum.eepw.com.cn/thread/262079/1/

關閉

Ethernet

Microcontroller

EPD Driver & SOC

Video Decoder

FAX/Modem

Medical & Apps

》》

Specifications

Hardware Design

Software Support

About Davicom

DAVICOM CSR

Investors

Products

Support

News

Career

Contact Us