STM32 + RT-Thread + LwIp + DM9000
一、概述
- 开发板：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文件在路径 src\netif 中 -
在 keil 中添加头文件路径 “src\include”
四、添加 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 <rtthread.h> static void red_dm9000_reg(int argv, char *argc[]) { if (argv != 2) { rt_kprintf("Please enter the correct command, such as dm9000_ Red 0 \r\n"); return; } rt_kprintf("0x%02X \r\n", 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 device\r\n"); 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:%d\r\n",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内存申请失败:%d\r\n", 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 < 0X40) || (rx_length > DM9000_PKT_MAX)) { LOG_E("rx_status:%#x\r\n", rx_status); if (rx_status & 0x100) LOG_E("rx fifo error\r\n"); if (rx_status & 0x200) LOG_E("rx crc error\r\n"); if (rx_status & 0x8000) LOG_E("rx length error\r\n"); if (rx_length > DM9000_PKT_MAX) { LOG_E("rx length too big\r\n"); 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 < q->len) { word[word_index++] = ((u8_t *)q->payload)[pbuf_index++]; if (word_index == 2) { DM9000->DATA = ((rt_uint16_t)word[1] << 8) | word[0]; word_index = 0; } } else { q = q->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 <rtthread.h>
#ifdef BSP_USING_ETH
#include "drv_config.h"
#include "drv_eth_dm9000.h"
#include <netif/ethernetif.h>
#include <lwipopts.h>
#include <drv_common.h>
#include <rthw.h>
/* debug option */
// #define DRV_DEBUG
#define LOG_TAG "drv.dm9000"
#include <drv_log.h>
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) << 8) | (DM9000_ReadReg(DM9000_EPDRL));
return temp;
}
/**
* @brief 复位DM9000
*/
void DM9000_Reset(void)
{
// 复位DM9000,复位步骤参考<DM9000 Application Notes V1.22>手册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 < 6; i++)
{
DM9000_WriteReg(DM9000_PAR + i, macaddr[i]);
}
}
/**
* @brief 设置DM9000的组播地址
* @param multicastaddr 指向多播地址
*/
void DM9000_Set_Multicast(rt_uint8_t *multicastaddr)
{
rt_uint8_t i;
for (i = 0; i < 8; i++)
{
DM9000_WriteReg(DM9000_MAR + i, multicastaddr[i]);
}
}
/**
* @brief 设置DM900的PHY工作模式
* @param mode PHY模式
*/
void DM9000_Set_PHYMode(rt_uint8_t mode)
{
rt_uint16_t BMCR_Value, ANAR_Value;
switch (mode)
{
case DM9000_10MHD: // 10M半双工
BMCR_Value = 0X0000;
ANAR_Value = 0X21;
break;
case DM9000_10MFD: // 10M全双工
BMCR_Value = 0X0100;
ANAR_Value = 0X41;
break;
case DM9000_100MHD: // 100M半双工
BMCR_Value = 0X2000;
ANAR_Value = 0X81;
break;
case DM9000_100MFD: // 100M全双工
BMCR_Value = 0X2100;
ANAR_Value = 0X101;
break;
case DM9000_AUTO: // 自动协商模式
BMCR_Value = 0X1000;
ANAR_Value = 0X01E1;
break;
}
DM9000_PHY_WriteReg(DM9000_PHY_BMCR, BMCR_Value);
DM9000_PHY_WriteReg(DM9000_PHY_ANAR, ANAR_Value);
DM9000_WriteReg(DM9000_GPR, 0X00); // 使能PHY
}
/**
* @brief 获取DM9000的芯片ID
* @return 返回值：DM9000的芯片ID值
*/
rt_uint32_t DM9000_Get_DeiviceID(void)
{
rt_uint32_t value;
value = DM9000_ReadReg(DM9000_VIDL);
value |= DM9000_ReadReg(DM9000_VIDH) << 8;
value |= DM9000_ReadReg(DM9000_PIDL) << 16;
value |= DM9000_ReadReg(DM9000_PIDH) << 24;
return value;
}
/**
* @brief 获取DM9000的连接速度和双工模式
* @return 返回值：0 是 100M半双工
* 1 是 100M全双工
* 2 是 10M半双工
* 3 是 10M全双工
* 0XFF 是连接失败！
*/
rt_uint8_t DM9000_Get_SpeedAndDuplex(void)
{
rt_uint8_t temp;
rt_uint8_t i = 0;
if (stm32_eth_device.eth_mode == DM9000_AUTO) // 如果开启了自动协商模式一定要等待协商完成
{
while (!(DM9000_PHY_ReadReg(0X01) & 0X0020)) // 等待自动协商完成
{
rt_thread_delay(100);
i++;
if (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 < q->len)
{
word[word_index++] = ((u8_t *)q->payload)[pbuf_index++];
if (word_index == 2)
{
DM9000->DATA = ((rt_uint16_t)word[1] << 8) | word[0];
word_index = 0;
}
}
else
{
q = q->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 device\r\n");
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:%d\r\n",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内存申请失败:%d\r\n", 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 < 0X40) || (rx_length > DM9000_PKT_MAX))
{
LOG_E("rx_status:%#x\r\n", rx_status);
if (rx_status & 0x100)
LOG_E("rx fifo error\r\n");
if (rx_status & 0x200)
LOG_E("rx crc error\r\n");
if (rx_status & 0x8000)
LOG_E("rx length error\r\n");
if (rx_length > DM9000_PKT_MAX)
{
LOG_E("rx length too big\r\n");
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("overflow\r\n");
if (int_status & ISR_ROOS)
rt_kprintf("overflow counter overflow \r\n");
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.... \r\n");
}
/**
* @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 mode\r\n", (temp & 0x02) ? 10 : 100, (temp & 0x01) ? "Full" : "Half");
}
else
{
LOG_E("DM9000 Establish Link Failed!\r\n");
}
/* 设置 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 <rtthread.h>
static void red_dm9000_reg(int argv, char *argc[])
{
if (argv != 2)
{
rt_kprintf("Please enter the correct command, such as dm9000_ Red 0 \r\n");
return;
}
rt_kprintf("0x%02X \r\n", 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 */
使用问题
-
问题一
最近测试的时候，发现拔出网线的时候，RTThread 的网卡状态不会改变，因此无法实现默认网卡的切换功能解决办法
新增 DM9000 link 改变的中断触发，程序改变如下
drv_eth_dm9000.h#define IMR_PAR 0x80 // DM9000的SRAM的发送和接收指针自动返回到开始地址 #define IMR_RESERVED 0x40 // 保留 #define IMR_LNKCHGI 0x20 // 使能链路状态更改中断 #define IMR_UDRUNI 0x10 // 使能传输不足中断 #define IMR_ROOI 0x08 // 使能接收溢出计数器溢出中断 #define IMR_POI 0x04 // 使能接收溢出中断 #define IMR_PTI 0x02 // 使能发送中断 #define IMR_PRI 0x01 // 使能接收中断drv_eth_dm9000.c
/* DM9000的SRAM的发送和接收指针自动返回到开始地址，并且开启接收中断 */ stm32_eth_device.imr_all = IMR_PAR | IMR_PRI | IMR_LNKCHGI; /** * @brief DM9000 管理线程 */ static void dm9000_monitor_thread_entry(void *parameter) { rt_uint32_t temp; rt_uint32_t event_flags; rt_err_t ret; /* 设置 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 mode\r\n", (temp & 0x02) ? 10 : 100, (temp & 0x01) ? "Full" : "Half"); } else { LOG_E("DM9000 Establish Link Failed!\r\n"); } /* 设置 DM900 为中断接收方式 */ DM9000_WriteReg(DM9000_IMR, stm32_eth_device.imr_all); /* 主循环 */ while(1) { /* 获取当前事件标志组状态 */ ret = rt_event_recv(event_interrupt, IMR_PRI_EVENT | IMR_LNKCHGI_EVENT, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &event_flags); if (ret == RT_EOK) { /* 线程中接收数据 */ if (event_flags & IMR_PRI_EVENT) { eth_device_linkchange(&stm32_eth_device.parent, RT_TRUE); } /* 链路状态改变事件 */ else if (event_flags & IMR_LNKCHGI_EVENT) { /* 判断是否断开连接 */ if (!(DM9000_ReadReg(DM9000_NSR) & 0X40)) { LOG_D("Connection fail.\n"); eth_device_linkchange(&stm32_eth_device.parent, RT_FALSE); } } } } } /** * @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); // LOG_D("RT_INT....%d \r\n", int_status); DM9000_WriteReg(DM9000_ISR, int_status); // 清除中断标志位，DM9000的ISR寄存器的bit0~bit5写1清零 if (int_status & ISR_ROS) LOG_I("overflow\r\n"); if (int_status & ISR_ROOS) LOG_I("overflow counter overflow \r\n"); if (int_status & ISR_PRS) // 接收中断 { rt_event_send(event_interrupt, IMR_PRI_EVENT); rt_schedule(); /* 调度，确保任务能及时响应事件 */ } if (int_status & ISR_PTS) // 发送中断 { // 发送完成中断，用户自行添加所需代码 } if (int_status & ISR_LNKCHGS) // 发送中断 { rt_event_send(event_interrupt, IMR_LNKCHGI_EVENT); } DM9000->REG = last_io; }
本文来自博客园，作者：浇筑菜鸟，转载请注明原文链接：https://www.cnblogs.com/jzcn/p/17457594.html
如本博客的内容侵犯了你的权益，请与以下地址联系，本人获知后，马上删除。同时本人深表歉意，并致以崇高的谢意！ cn_jiaozhu@qq.com
