一、概述
- 开发板：STM32F103ZET6（战舰）
- RT-Thread：5.0.0
- LwIp：2.1.2
- 网卡芯片：DM9000
- 编译环境：keil
我简单了解了一下，在嵌入式中，网络芯片的使用方式大致有三种，如下：
- (MCU + MAC + PHY)
- (MUC + MAC) —— PHY
- MCU —— (MAC + PHY)
注意：我用括号里面的表示在同一块芯片中
二、RT-Thread 移植
移植 RT-Thread 不是此文章的重点，可以参考一下我之前的笔记，或者直接使用 RT-Thread Studio、STM32CubeMX等工具直接生成，这里我就不过多介绍了
三、添加 LwIp
-
添加使用是需要的API文件
-
添加内核源码
注意：这里的动态内存是使用的RT-Thread中完成的，在 sys_arch.c 文件中完成 -
添加IPv4或者IPv6需要使用的文件，这里我只用到了IPv4，所以没有添加IPv6的文件、
-
添加网卡文件
注意：ethernet文件在路径 srcnetif 中 -
在 keil 中添加头文件路径 “srcinclude”
四、添加 LwIp 需要的头文件
五、添加驱动文件
RT-Thread 已经写好了驱动，我们值需要拷贝就行，不需要更改其中的内容，主要需要的文件有 sys_arch.c、sys_arch.h、ethernetif.c、ethernetif.h。
其中 sys_arch 文件主要实现了 LwIp 在操作系统下需要的功能好书，比如线程的创建、信号量、锁等功能。
ethernetif 文件主要实现 LwIp的驱动实现，移植时明白接收线程和发送线程的工作，相对就比较简单了。
完成以上步奏后，编译应该是可以通过的，接下来值需要完成 BSP 程序的实现即可。
六、BSP 驱动文件
以上的操作都不需要我们编写代码的，只需要完成 BSP 部分的代码即可，因为我用的是正点原子的战舰开发板，所以这里我直接使用 DM9000 部分的代码，进行简单更改即可。
-
注册网卡
/** * @brief 注册网卡设备 */ static int rt_hw_stm32_eth_init(void) { rt_err_t state = RT_EOK; /* 设置工作方式为自动模式 */ stm32_eth_device.eth_mode = DM9000_AUTO; /* DM9000的SRAM的发送和接收指针自动返回到开始地址，并且开启接收中断 */ stm32_eth_device.imr_all = IMR_PAR | IMR_PRI; /* 前三位可以自定义 */ stm32_eth_device.dev_addr[0] = 0x02; stm32_eth_device.dev_addr[1] = 0x00; stm32_eth_device.dev_addr[2] = 0x00; /* 根据 96 位唯一 ID 生成 MAC 地址（仅用于测试） */ stm32_eth_device.dev_addr[3] = *(rt_uint8_t *)(UID_BASE + 4); stm32_eth_device.dev_addr[4] = *(rt_uint8_t *)(UID_BASE + 2); stm32_eth_device.dev_addr[5] = *(rt_uint8_t *)(UID_BASE + 0); // 初始化组播地址 stm32_eth_device.multicase_addr[0] = 0Xff; stm32_eth_device.multicase_addr[1] = 0Xff; stm32_eth_device.multicase_addr[2] = 0Xff; stm32_eth_device.multicase_addr[3] = 0Xff; stm32_eth_device.multicase_addr[4] = 0Xff; stm32_eth_device.multicase_addr[5] = 0Xff; stm32_eth_device.multicase_addr[6] = 0Xff; stm32_eth_device.multicase_addr[7] = 0Xff; stm32_eth_device.parent.parent.init = rt_stm32_eth_init; stm32_eth_device.parent.parent.open = rt_stm32_eth_open; stm32_eth_device.parent.parent.close = rt_stm32_eth_close; stm32_eth_device.parent.parent.read = rt_stm32_eth_read; stm32_eth_device.parent.parent.write = rt_stm32_eth_write; stm32_eth_device.parent.parent.control = rt_stm32_eth_control; stm32_eth_device.parent.parent.user_data = RT_NULL; stm32_eth_device.parent.eth_rx = rt_stm32_eth_rx; stm32_eth_device.parent.eth_tx = rt_stm32_eth_tx; /* 注册网卡设备 */ state = eth_device_init(&(stm32_eth_device.parent), "e0"); if (RT_EOK != state) { LOG_E("emac device init faild: %d", state); return -RT_ERROR; } /* 初始化DM9000 */ state = DM9000_Init(); if (RT_EOK != state) { LOG_E("DM9000 initialization failed"); return -RT_ERROR; } /* 启动 PHY 监视器, 在线程中完成网卡的配置 */ rt_thread_t tid; tid = rt_thread_create("dm9000", dm9000_monitor_thread_entry, RT_NULL, 1024, RT_THREAD_PRIORITY_MAX - 2, 2); if (tid != RT_NULL) { rt_thread_startup(tid); state = RT_EOK; } else { state = -RT_ERROR; } return state; } INIT_DEVICE_EXPORT(rt_hw_stm32_eth_init); #ifdef RT_USING_FINSH #include static void red_dm9000_reg(int argv, char *argc[]) { if (argv != 2) { rt_kprintf("Please enter the correct command, such as dm9000_ Red 0 rn"); return; } rt_kprintf("0x%02X rn", DM9000_ReadReg(atoi(argc[1]))); } MSH_CMD_EXPORT_ALIAS(red_dm9000_reg, DM9000_read_reg, Read the register value of DM9000); -
读取函数的实现
/** * @brief DM9000接收数据包,接收到的数据包存放在DM9000的RX FIFO中，地址为0X0C00~0X3FFF * 接收到的数据包的前四个字节并不是真实的数据，而是有特定含义的，如下 * byte1:表明是否接收到数据，为0x00或者0X01，如果两个都不是的话一定要软件复位DM9000 * 0x01，接收到数据 * 0x00，未接收到数据 * byte2:第二个字节表示一些状态信息，和DM9000的RSR(0X06)寄存器一致的 * byte3:本帧数据长度的低字节 * byte4:本帧数据长度的高字节 * @return pbuf格式的接收到的数据包 */ struct pbuf *rt_stm32_eth_rx(rt_device_t dev) { // LOG_E("rt_stm32_eth_rx"); struct pbuf *p; struct pbuf *q; rt_uint8_t rxbyte; volatile rt_uint16_t rx_status, rx_length; rt_uint16_t *data; rt_uint16_t dummy; rt_int32_t len; p = NULL; __error_retry: DM9000_ReadReg(DM9000_MRCMDX); // 假读 rxbyte = (rt_uint8_t)DM9000->DATA; // 进行第二次读取 if (rxbyte) // 接收到数据 { if (rxbyte > 1) // rxbyte大于1，接收到的数据错误,挂了 { LOG_E("dm9000 rx: rx error, stop devicern"); DM9000_WriteReg(DM9000_RCR, 0x00); DM9000_WriteReg(DM9000_ISR, 0x80); return (struct pbuf *)p; } DM9000->REG = DM9000_MRCMD; rx_status = DM9000->DATA; rx_length = DM9000->DATA; // if(rx_length>512)printf("rxlen:%drn",rx_length); p = pbuf_alloc(PBUF_RAW, rx_length, PBUF_POOL); // pbufs内存池分配pbuf if (p != NULL) // 内存申请成功 { for (q = p; q != NULL; q = q->next) { data = (rt_uint16_t *)q->payload; len = q->len; while (len > 0) { *data = DM9000->DATA; data++; len -= 2; } } } else // 内存申请失败 { LOG_E("pbuf内存申请失败:%drn", rx_length); data = &dummy; len = rx_length; while (len) { *data = DM9000->DATA; len -= 2; } } // 根据rx_status判断接收数据是否出现如下错误：FIFO溢出、CRC错误 // 对齐错误、物理层错误，如果有任何一个出现的话丢弃该数据帧， // 当rx_length小于64或者大于最大数据长度的时候也丢弃该数据帧 if ((rx_status & 0XBF00) || (rx_length DM9000_PKT_MAX)) { LOG_E("rx_status:%#xrn", rx_status); if (rx_status & 0x100) LOG_E("rx fifo errorrn"); if (rx_status & 0x200) LOG_E("rx crc errorrn"); if (rx_status & 0x8000) LOG_E("rx length errorrn"); if (rx_length > DM9000_PKT_MAX) { LOG_E("rx length too bigrn"); DM9000_WriteReg(DM9000_NCR, NCR_RST); // 复位DM9000 rt_thread_delay(10); } if (p != NULL) pbuf_free((struct pbuf *)p); // 释放内存 p = NULL; goto __error_retry; } } else { DM9000_WriteReg(DM9000_ISR, ISR_PTS); // 清除所有中断标志位 stm32_eth_device.imr_all = IMR_PAR | IMR_PRI; // 重新接收中断 DM9000_WriteReg(DM9000_IMR, stm32_eth_device.imr_all); } return (struct pbuf *)p; } -
写入函数的实现
/** * @brief 通过DM9000发送数据包 * @param dev 设备结构体 * @param p pbuf结构体指针 */ rt_err_t rt_stm32_eth_tx(rt_device_t dev, struct pbuf *p) { struct pbuf *q; rt_uint16_t pbuf_index = 0; rt_uint8_t word[2], word_index = 0; DM9000_WriteReg(DM9000_IMR, IMR_PAR); // 关闭网卡中断 DM9000->REG = DM9000_MWCMD; // 发送此命令后就可以将要发送的数据搬到DM9000 TX SRAM中 q = p; // 向DM9000的TX SRAM中写入数据，一次写入两个字节数据 // 当要发送的数据长度为奇数的时候，我们需要将最后一个字节单独写入DM9000的TX SRAM中 while (q) { if (pbuf_index len) { word[word_index++] = ((u8_t *)q->payload)[pbuf_index++]; if (word_index == 2) { DM9000->DATA = ((rt_uint16_t)word[1] next; pbuf_index = 0; } } // 还有一个字节未写入TX SRAM if (word_index == 1) DM9000->DATA = word[0]; // 向DM9000写入发送长度 DM9000_WriteReg(DM9000_TXPLL, p->tot_len & 0XFF); DM9000_WriteReg(DM9000_TXPLH, (p->tot_len >> 8) & 0XFF); // 设置要发送数据的数据长度 DM9000_WriteReg(DM9000_TCR, 0X01); // 启动发送 while ((DM9000_ReadReg(DM9000_ISR) & 0X02) == 0) ; // 等待发送完成 DM9000_WriteReg(DM9000_ISR, 0X02); // 清除发送完成中断 DM9000_WriteReg(DM9000_IMR, stm32_eth_device.imr_all); // DM9000网卡接收中断使能 return ERR_OK; }
七、BSP 驱动文件
#include
#ifdef BSP_USING_ETH
#include "drv_config.h"
#include "drv_eth_dm9000.h"
#include
#include
#include
#include
/* debug option */
// #define DRV_DEBUG
#define LOG_TAG "drv.dm9000"
#include
struct rt_stm32_eth
{
/* 从 LwIp 中继承 */
struct eth_device parent;
#ifndef PHY_USING_INTERRUPT_MODE
rt_timer_t poll_link_timer;
#endif
/* 网卡模式 */
DM9000_PHY_mode eth_mode;
/* 中断类型 */
rt_uint8_t imr_all;
/* 每个数据包大小 */
rt_uint16_t queue_packet_len;
/* 设备 MAC 地址 */
rt_uint8_t dev_addr[MAX_ADDR_LEN];
/* 组播地址 */
rt_uint8_t multicase_addr[MULTICASE_ADDR_LEN];
};
/* 网卡设备结构体 */
static struct rt_stm32_eth stm32_eth_device;
/* 注意：SRAM 句柄不能为局部变量 */
SRAM_HandleTypeDef DM9000_Handler; // SRAM句柄
/**
* @brief 初始化DM9000
*/
rt_err_t DM9000_Init(void)
{
int result = RT_EOK;
/* 配置 GPIO */
GPIO_InitTypeDef GPIO_InitStruct;
/* FSMC */
FSMC_NORSRAM_TimingTypeDef DM9000_Timing;
/*----------------------------------------- 使能时钟 -----------------------------------------*/
__HAL_RCC_GPIOD_CLK_ENABLE(); // 使能GPIOD时钟
__HAL_RCC_GPIOE_CLK_ENABLE(); // 使能GPIOE时钟
__HAL_RCC_GPIOF_CLK_ENABLE(); // 使能GPIOF时钟
__HAL_RCC_GPIOG_CLK_ENABLE(); // 使能GPIOG时钟
__HAL_RCC_FSMC_CLK_ENABLE(); // 使能FSMC时钟
__HAL_RCC_AFIO_CLK_ENABLE(); // 使能复用功能时钟
/* PD7 网卡的复位引脚 */
GPIO_InitStruct.Pin = GPIO_PIN_7;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; // 推挽输出
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/* PD0 1 4 5 8 9 10 14 15复用 */
GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_4 | GPIO_PIN_5 |
GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_14 | GPIO_PIN_15;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; // 复用推挽输出
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/* PG7 8 9 10 11 12 13 14 15复用 */
GPIO_InitStruct.Pin = GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 |
GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; // 复用推挽输出
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
/* PF13复用 */
GPIO_InitStruct.Pin = GPIO_PIN_13;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; // 复用推挽输出
HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
/* PG9复用 */
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; // 复用推挽输出
HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
/*----------------------------------------- 配置 SRAM -----------------------------------------*/
DM9000_Handler.Instance = FSMC_NORSRAM_DEVICE;
DM9000_Handler.Extended = FSMC_NORSRAM_EXTENDED_DEVICE;
DM9000_Handler.Init.NSBank = FSMC_NORSRAM_BANK2; // 使用NE2
DM9000_Handler.Init.DataAddressMux = FSMC_DATA_ADDRESS_MUX_DISABLE; // 地址/数据线不复用
DM9000_Handler.Init.MemoryType = FSMC_MEMORY_TYPE_SRAM; // SRAM
DM9000_Handler.Init.MemoryDataWidth = FSMC_NORSRAM_MEM_BUS_WIDTH_16; // 16位数据宽度
DM9000_Handler.Init.BurstAccessMode = FSMC_BURST_ACCESS_MODE_DISABLE; // 是否使能突发访问,仅对同步突发存储器有效,此处未用到
DM9000_Handler.Init.WaitSignalPolarity = FSMC_WAIT_SIGNAL_POLARITY_LOW; // 等待信号的极性,仅在突发模式访问下有用
DM9000_Handler.Init.WaitSignalActive = FSMC_WAIT_TIMING_BEFORE_WS; // 存储器是在等待周期之前的一个时钟周期还是等待周期期间使能NWAIT
DM9000_Handler.Init.WriteOperation = FSMC_WRITE_OPERATION_ENABLE; // 存储器写使能
DM9000_Handler.Init.WaitSignal = FSMC_WAIT_SIGNAL_DISABLE; // 等待使能位,此处未用到
DM9000_Handler.Init.ExtendedMode = FSMC_EXTENDED_MODE_DISABLE; // 读写使用相同的时序
DM9000_Handler.Init.AsynchronousWait = FSMC_ASYNCHRONOUS_WAIT_DISABLE; // 是否使能同步传输模式下的等待信号,此处未用到
DM9000_Handler.Init.WriteBurst = FSMC_WRITE_BURST_DISABLE; // 禁止突发写
/*----------------------------------------- FSMC 读写时序控制 -----------------------------------------*/
DM9000_Timing.AddressSetupTime = 0x00; // 地址建立时间（ADDSET）为1个HCLK 1/72M = 13.8ns
DM9000_Timing.AddressHoldTime = 0x00; // 地址保持时间（ADDHLD）模式A未用到
DM9000_Timing.DataSetupTime = 0x03; // 数据保存时间为3个HCLK = 4*13.8 = 55ns
DM9000_Timing.BusTurnAroundDuration = 0X00;
DM9000_Timing.CLKDivision = 0X00;
DM9000_Timing.DataLatency = 0X00;
DM9000_Timing.AccessMode = FSMC_ACCESS_MODE_A; // 模式A
/* 使能FSMC的Bank1_Bank1_NORSRAM2 */
if (HAL_SRAM_Init(&DM9000_Handler, &DM9000_Timing, &DM9000_Timing) != HAL_OK)
{
LOG_E("SDRAM init failed!");
result = -RT_ERROR;
}
return result;
}
/**
* @brief 向DM9000指定寄存器中写入指定值
* @param reg 要写入的寄存器
* @param data 要写入的值
*/
void DM9000_WriteReg(rt_uint16_t reg, rt_uint16_t data)
{
DM9000->REG = reg;
DM9000->DATA = data;
}
/**
* @brief 读取DM9000指定寄存器的值
* @param reg 寄存器地址
* @param data DM9000指定寄存器的值
*/
rt_uint16_t DM9000_ReadReg(rt_uint16_t reg)
{
DM9000->REG = reg;
return DM9000->DATA;
}
/**
* @brief 向DM9000的PHY寄存器写入指定值
* @param reg PHY寄存器
* @param data 要写入的值
*/
void DM9000_PHY_WriteReg(rt_uint16_t reg, rt_uint16_t data)
{
DM9000_WriteReg(DM9000_EPAR, DM9000_PHY | reg);
DM9000_WriteReg(DM9000_EPDRL, (data & 0xff)); // 写入低字节
DM9000_WriteReg(DM9000_EPDRH, ((data >> 8) & 0xff)); // 写入高字节
DM9000_WriteReg(DM9000_EPCR, 0X0A); // 选中PHY,发送写命令
rt_thread_delay(50);
DM9000_WriteReg(DM9000_EPCR, 0X00); // 清除写命令
}
/**
* @brief 读取DM9000的PHY的指定寄存器
* @param reg 要读的PHY寄存器
* @return 返回值:读取到的PHY寄存器值
*/
rt_uint16_t DM9000_PHY_ReadReg(rt_uint16_t reg)
{
rt_uint16_t temp;
DM9000_WriteReg(DM9000_EPAR, DM9000_PHY | reg);
DM9000_WriteReg(DM9000_EPCR, 0X0C); // 选中PHY，发送读命令
rt_thread_delay(10);
DM9000_WriteReg(DM9000_EPCR, 0X00); // 清除读命令
temp = (DM9000_ReadReg(DM9000_EPDRH) 手册29页
DM9000_RST(0); // DM9000硬件复位
rt_thread_delay(10);
DM9000_RST(1); // DM9000硬件复位结束
rt_thread_delay(100); // 一定要有这个延时，让DM9000准备就绪！
DM9000_WriteReg(DM9000_GPCR, 0x01); // 第一步:设置GPCR寄存器(0X1E)的bit0为1
DM9000_WriteReg(DM9000_GPR, 0); // 第二步:设置GPR寄存器(0X1F)的bit1为0，DM9000内部的PHY上电
DM9000_WriteReg(DM9000_NCR, (0x02 | NCR_RST)); // 第三步:软件复位DM9000
do
{
rt_thread_delay(25);
} while (DM9000_ReadReg(DM9000_NCR) & 1); // 等待DM9000软复位完成
DM9000_WriteReg(DM9000_NCR, 0);
DM9000_WriteReg(DM9000_NCR, (0x02 | NCR_RST)); // DM9000第二次软复位
do
{
rt_thread_delay(25);
} while (DM9000_ReadReg(DM9000_NCR) & 1);
}
/**
* @brief 设置DM9000的MAC地址
* @param macaddr 指向MAC地址
*/
void DM9000_Set_MACAddress(rt_uint8_t *macaddr)
{
rt_uint8_t i;
for (i = 0; i 100)
return 0XFF; // 自动协商失败
}
}
else // 自定义模式,一定要等待连接成功
{
while (!(DM9000_ReadReg(DM9000_NSR) & 0X40)) // 等待连接成功
{
rt_thread_delay(100);
i++;
if (i > 100)
return 0XFF; // 连接失败
}
}
temp = ((DM9000_ReadReg(DM9000_NSR) >> 6) & 0X02); // 获取DM9000的连接速度
temp |= ((DM9000_ReadReg(DM9000_NCR) >> 3) & 0X01); // 获取DM9000的双工状态
return temp;
}
static rt_err_t rt_stm32_eth_init(rt_device_t dev)
{
return RT_EOK;
}
static rt_err_t rt_stm32_eth_open(rt_device_t dev, rt_uint16_t oflag)
{
LOG_D("emac open");
return RT_EOK;
}
static rt_err_t rt_stm32_eth_close(rt_device_t dev)
{
LOG_D("emac close");
return RT_EOK;
}
static rt_size_t rt_stm32_eth_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
{
LOG_D("emac read");
rt_set_errno(-RT_ENOSYS);
return 0;
}
static rt_size_t rt_stm32_eth_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
LOG_D("emac write");
rt_set_errno(-RT_ENOSYS);
return 0;
}
static rt_err_t rt_stm32_eth_control(rt_device_t dev, int cmd, void *args)
{
LOG_D("rt_stm32_eth_control");
switch (cmd)
{
case NIOCTL_GADDR:
/* get mac address */
if (args)
{
SMEMCPY(args, stm32_eth_device.dev_addr, 6);
}
else
{
return -RT_ERROR;
}
break;
default:
break;
}
return RT_EOK;
}
/**
* @brief 通过DM9000发送数据包
* @param dev 设备结构体
* @param p pbuf结构体指针
*/
rt_err_t rt_stm32_eth_tx(rt_device_t dev, struct pbuf *p)
{
struct pbuf *q;
rt_uint16_t pbuf_index = 0;
rt_uint8_t word[2], word_index = 0;
DM9000_WriteReg(DM9000_IMR, IMR_PAR); // 关闭网卡中断
DM9000->REG = DM9000_MWCMD; // 发送此命令后就可以将要发送的数据搬到DM9000 TX SRAM中
q = p;
// 向DM9000的TX SRAM中写入数据，一次写入两个字节数据
// 当要发送的数据长度为奇数的时候，我们需要将最后一个字节单独写入DM9000的TX SRAM中
while (q)
{
if (pbuf_index len)
{
word[word_index++] = ((u8_t *)q->payload)[pbuf_index++];
if (word_index == 2)
{
DM9000->DATA = ((rt_uint16_t)word[1] next;
pbuf_index = 0;
}
}
// 还有一个字节未写入TX SRAM
if (word_index == 1)
DM9000->DATA = word[0];
// 向DM9000写入发送长度
DM9000_WriteReg(DM9000_TXPLL, p->tot_len & 0XFF);
DM9000_WriteReg(DM9000_TXPLH, (p->tot_len >> 8) & 0XFF); // 设置要发送数据的数据长度
DM9000_WriteReg(DM9000_TCR, 0X01); // 启动发送
while ((DM9000_ReadReg(DM9000_ISR) & 0X02) == 0)
; // 等待发送完成
DM9000_WriteReg(DM9000_ISR, 0X02); // 清除发送完成中断
DM9000_WriteReg(DM9000_IMR, stm32_eth_device.imr_all); // DM9000网卡接收中断使能
return ERR_OK;
}
/**
* @brief DM9000接收数据包,接收到的数据包存放在DM9000的RX FIFO中，地址为0X0C00~0X3FFF
* 接收到的数据包的前四个字节并不是真实的数据，而是有特定含义的，如下
* byte1:表明是否接收到数据，为0x00或者0X01，如果两个都不是的话一定要软件复位DM9000
* 0x01，接收到数据
* 0x00，未接收到数据
* byte2:第二个字节表示一些状态信息，和DM9000的RSR(0X06)寄存器一致的
* byte3:本帧数据长度的低字节
* byte4:本帧数据长度的高字节
* @return pbuf格式的接收到的数据包
*/
struct pbuf *rt_stm32_eth_rx(rt_device_t dev)
{
// LOG_E("rt_stm32_eth_rx");
struct pbuf *p;
struct pbuf *q;
rt_uint8_t rxbyte;
volatile rt_uint16_t rx_status, rx_length;
rt_uint16_t *data;
rt_uint16_t dummy;
rt_int32_t len;
p = NULL;
__error_retry:
DM9000_ReadReg(DM9000_MRCMDX); // 假读
rxbyte = (rt_uint8_t)DM9000->DATA; // 进行第二次读取
if (rxbyte) // 接收到数据
{
if (rxbyte > 1) // rxbyte大于1，接收到的数据错误,挂了
{
LOG_E("dm9000 rx: rx error, stop devicern");
DM9000_WriteReg(DM9000_RCR, 0x00);
DM9000_WriteReg(DM9000_ISR, 0x80);
return (struct pbuf *)p;
}
DM9000->REG = DM9000_MRCMD;
rx_status = DM9000->DATA;
rx_length = DM9000->DATA;
// if(rx_length>512)printf("rxlen:%drn",rx_length);
p = pbuf_alloc(PBUF_RAW, rx_length, PBUF_POOL); // pbufs内存池分配pbuf
if (p != NULL) // 内存申请成功
{
for (q = p; q != NULL; q = q->next)
{
data = (rt_uint16_t *)q->payload;
len = q->len;
while (len > 0)
{
*data = DM9000->DATA;
data++;
len -= 2;
}
}
}
else // 内存申请失败
{
LOG_E("pbuf内存申请失败:%drn", rx_length);
data = &dummy;
len = rx_length;
while (len)
{
*data = DM9000->DATA;
len -= 2;
}
}
// 根据rx_status判断接收数据是否出现如下错误：FIFO溢出、CRC错误
// 对齐错误、物理层错误，如果有任何一个出现的话丢弃该数据帧，
// 当rx_length小于64或者大于最大数据长度的时候也丢弃该数据帧
if ((rx_status & 0XBF00) || (rx_length DM9000_PKT_MAX))
{
LOG_E("rx_status:%#xrn", rx_status);
if (rx_status & 0x100)
LOG_E("rx fifo errorrn");
if (rx_status & 0x200)
LOG_E("rx crc errorrn");
if (rx_status & 0x8000)
LOG_E("rx length errorrn");
if (rx_length > DM9000_PKT_MAX)
{
LOG_E("rx length too bigrn");
DM9000_WriteReg(DM9000_NCR, NCR_RST); // 复位DM9000
rt_thread_delay(10);
}
if (p != NULL)
pbuf_free((struct pbuf *)p); // 释放内存
p = NULL;
goto __error_retry;
}
}
else
{
DM9000_WriteReg(DM9000_ISR, ISR_PTS); // 清除所有中断标志位
stm32_eth_device.imr_all = IMR_PAR | IMR_PRI; // 重新接收中断
DM9000_WriteReg(DM9000_IMR, stm32_eth_device.imr_all);
}
return (struct pbuf *)p;
}
/**
* @brief DM9000 中断处理函数
*/
static void eth_phy_isr(void *args)
{
rt_uint16_t int_status;
rt_uint16_t last_io;
last_io = DM9000->REG;
int_status = DM9000_ReadReg(DM9000_ISR);
DM9000_WriteReg(DM9000_ISR, int_status); // 清除中断标志位，DM9000的ISR寄存器的bit0~bit5写1清零
if (int_status & ISR_ROS)
rt_kprintf("overflowrn");
if (int_status & ISR_ROOS)
rt_kprintf("overflow counter overflow rn");
if (int_status & ISR_PRS) // 接收中断
{
/* 线程中接收数据 */
eth_device_linkchange(&stm32_eth_device.parent, RT_TRUE);
// eth_device_linkchange(&stm32_eth_device.parent, RT_FALSE);
}
if (int_status & ISR_PTS) // 发送中断
{
// 发送完成中断，用户自行添加所需代码
}
DM9000->REG = last_io;
// rt_kprintf("RT_INT.... rn");
}
/**
* @brief DM9000 管理线程
*/
static void dm9000_monitor_thread_entry(void *parameter)
{
rt_uint32_t temp;
/* 设置 PG6 引脚为外部中断 */
rt_pin_mode(PHY_INT_PIN, PIN_MODE_INPUT_PULLUP);
rt_pin_attach_irq(PHY_INT_PIN, PIN_IRQ_MODE_FALLING, eth_phy_isr, (void *)"callbackargs");
rt_pin_irq_enable(PHY_INT_PIN, PIN_IRQ_ENABLE);
/* 复位DM9000 */
DM9000_Reset();
rt_thread_delay(100);
/* 判断是否复位成功 */
temp = DM9000_Get_DeiviceID(); // 获取DM9000ID
if (temp != DM9000_ID) // 读取ID错误
{
LOG_E("DM9000 reset failed");
return;
}
LOG_D("DM9000 ID: %#x", temp);
/* 设置PHY工作模式 */
DM9000_Set_PHYMode(stm32_eth_device.eth_mode);
DM9000_WriteReg(DM9000_NCR, 0X00);
DM9000_WriteReg(DM9000_TCR, 0X00); // 发送控制寄存器清零
DM9000_WriteReg(DM9000_BPTR, 0X3F);
DM9000_WriteReg(DM9000_FCTR, 0X38);
DM9000_WriteReg(DM9000_FCR, 0X00);
DM9000_WriteReg(DM9000_SMCR, 0X00); // 特殊模式
DM9000_WriteReg(DM9000_NSR, NSR_WAKEST | NSR_TX2END | NSR_TX1END); // 清除发送状态
DM9000_WriteReg(DM9000_ISR, 0X0F); // 清除中断状态
DM9000_WriteReg(DM9000_TCR2, 0X80); // 切换LED到mode1
/* 设置MAC地址和组播地址 */
DM9000_Set_MACAddress(stm32_eth_device.dev_addr); // 设置MAC地址
DM9000_Set_Multicast(stm32_eth_device.multicase_addr); // 设置组播地址
DM9000_WriteReg(DM9000_RCR, RCR_DIS_LONG | RCR_DIS_CRC | RCR_RXEN);
DM9000_WriteReg(DM9000_IMR, IMR_PAR);
/* 获取DM9000的连接速度和双工状态 */
temp = DM9000_Get_SpeedAndDuplex();
if (temp != 0XFF) // 连接成功，通过串口显示连接速度和双工状态
{
LOG_I("DM9000 Speed:%dMbps,Duplex:%s duplex modern", (temp & 0x02) ? 10 : 100, (temp & 0x01) ? "Full" : "Half");
}
else
{
LOG_E("DM9000 Establish Link Failed!rn");
}
/* 设置 DM900 为中断接收方式 */
DM9000_WriteReg(DM9000_IMR, stm32_eth_device.imr_all);
}
/**
* @brief 注册网卡设备
*/
static int rt_hw_stm32_eth_init(void)
{
rt_err_t state = RT_EOK;
/* 设置工作方式为自动模式 */
stm32_eth_device.eth_mode = DM9000_AUTO;
/* DM9000的SRAM的发送和接收指针自动返回到开始地址，并且开启接收中断 */
stm32_eth_device.imr_all = IMR_PAR | IMR_PRI;
/* 前三位可以自定义 */
stm32_eth_device.dev_addr[0] = 0x02;
stm32_eth_device.dev_addr[1] = 0x00;
stm32_eth_device.dev_addr[2] = 0x00;
/* 根据 96 位唯一 ID 生成 MAC 地址（仅用于测试） */
stm32_eth_device.dev_addr[3] = *(rt_uint8_t *)(UID_BASE + 4);
stm32_eth_device.dev_addr[4] = *(rt_uint8_t *)(UID_BASE + 2);
stm32_eth_device.dev_addr[5] = *(rt_uint8_t *)(UID_BASE + 0);
// 初始化组播地址
stm32_eth_device.multicase_addr[0] = 0Xff;
stm32_eth_device.multicase_addr[1] = 0Xff;
stm32_eth_device.multicase_addr[2] = 0Xff;
stm32_eth_device.multicase_addr[3] = 0Xff;
stm32_eth_device.multicase_addr[4] = 0Xff;
stm32_eth_device.multicase_addr[5] = 0Xff;
stm32_eth_device.multicase_addr[6] = 0Xff;
stm32_eth_device.multicase_addr[7] = 0Xff;
stm32_eth_device.parent.parent.init = rt_stm32_eth_init;
stm32_eth_device.parent.parent.open = rt_stm32_eth_open;
stm32_eth_device.parent.parent.close = rt_stm32_eth_close;
stm32_eth_device.parent.parent.read = rt_stm32_eth_read;
stm32_eth_device.parent.parent.write = rt_stm32_eth_write;
stm32_eth_device.parent.parent.control = rt_stm32_eth_control;
stm32_eth_device.parent.parent.user_data = RT_NULL;
stm32_eth_device.parent.eth_rx = rt_stm32_eth_rx;
stm32_eth_device.parent.eth_tx = rt_stm32_eth_tx;
/* 注册网卡设备 */
state = eth_device_init(&(stm32_eth_device.parent), "e0");
if (RT_EOK != state)
{
LOG_E("emac device init faild: %d", state);
return -RT_ERROR;
}
/* 初始化DM9000 */
state = DM9000_Init();
if (RT_EOK != state)
{
LOG_E("DM9000 initialization failed");
return -RT_ERROR;
}
/* 启动 PHY 监视器, 在线程中完成网卡的配置 */
rt_thread_t tid;
tid = rt_thread_create("dm9000",
dm9000_monitor_thread_entry,
RT_NULL,
1024,
RT_THREAD_PRIORITY_MAX - 2,
2);
if (tid != RT_NULL)
{
rt_thread_startup(tid);
state = RT_EOK;
}
else
{
state = -RT_ERROR;
}
return state;
}
INIT_DEVICE_EXPORT(rt_hw_stm32_eth_init);
#ifdef RT_USING_FINSH
#include
static void red_dm9000_reg(int argv, char *argc[])
{
if (argv != 2)
{
rt_kprintf("Please enter the correct command, such as dm9000_ Red 0 rn");
return;
}
rt_kprintf("0x%02X rn", DM9000_ReadReg(atoi(argc[1])));
}
MSH_CMD_EXPORT_ALIAS(red_dm9000_reg, DM9000_read_reg, Read the register value of DM9000);
#endif /* RT_USING_FINSH */
#endif /* BSP_USING_LCD */
服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net
机房租用，北京机房租用，IDC机房托管， http://www.fwqtg.net
RabbitMQ系列-概念及安装
RabbitMQ系列 RabbitMQ系列-概念及安装 1. Exchange RabbitMQ系列-概念及安装 提到AMQP 0-9-1协议默认支持四种exchange，分别是Direct Exchange，Fanout Exchange，Topi…
