【易开嵌入式】rt-thread+stm32f407，实现RL-TCPnet网络协议栈
作者：互联网
前文：【易开嵌入式】rt-thread+stm32f407+nandflash，实现RL-FLASHFS文件系统移植
版权声明：本版面文章皆为原创、或参考其他技术网站、博客后自己动手做实验所得，转载请注明出处。
鸣谢：感谢eric硬汉
商务合作：lz_kwok@163.com
易开嵌入式工作室
本文重点讲述，使用stm32最新hal库，基于rt-thread操作系统，移植RL-TCPnet的流程。
参考【前文】描述，编写kconfig和sconsript脚本，将源码源码加入rtt的工程中：
数据收发采用中断模式，需要实现以下几个接口：
void init_ethernet () //初始化以太网控制器。
void send_frame (OS_FRAME *frame)//发送数据包给以太网控制器。
void int_enable_eth () //使能以太网控制器中断。
void int_disable_eth () //关闭以太网控制器中断。
HAL_ETH_RxCpltCallback//中断函数，主要用于数据包的接收
使用hal库，实现方法如下：
首先是init_ethernet函数
/* Register the EMAC device */
int init_ethernet(void)
{
rt_err_t state = RT_EOK;
/* Prepare receive and send buffers */
Rx_Buff = (rt_uint8_t *)rt_calloc(ETH_RXBUFNB, ETH_MAX_PACKET_SIZE);
if (Rx_Buff == RT_NULL)
{
LOG_E("No memory");
state = -RT_ENOMEM;
goto __exit;
}
Tx_Buff = (rt_uint8_t *)rt_calloc(ETH_TXBUFNB, ETH_MAX_PACKET_SIZE);
if (Tx_Buff == RT_NULL)
{
LOG_E("No memory");
state = -RT_ENOMEM;
goto __exit;
}
DMARxDscrTab = (ETH_DMADescTypeDef *)rt_calloc(ETH_RXBUFNB, sizeof(ETH_DMADescTypeDef));
if (DMARxDscrTab == RT_NULL)
{
LOG_E("No memory");
state = -RT_ENOMEM;
goto __exit;
}
DMATxDscrTab = (ETH_DMADescTypeDef *)rt_calloc(ETH_TXBUFNB, sizeof(ETH_DMADescTypeDef));
if (DMATxDscrTab == RT_NULL)
{
LOG_E("No memory");
state = -RT_ENOMEM;
goto __exit;
}
#ifdef RT_USING_LWIP
stm32_eth_device.ETH_Speed = ETH_SPEED_100M;
stm32_eth_device.ETH_Mode = ETH_MODE_FULLDUPLEX;
/* OUI 00-80-E1 STMICROELECTRONICS. */
stm32_eth_device.dev_addr[0] = 0x00;
stm32_eth_device.dev_addr[1] = 0x80;
stm32_eth_device.dev_addr[2] = 0xE1;
/* generate MAC addr from 96bit unique ID (only for test). */
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.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;
/* register eth device */
state = eth_device_init(&(stm32_eth_device.parent), "eth0");
if (RT_EOK == state)
{
LOG_D("emac device init success");
}
else
{
LOG_E("emac device init faild: %d", state);
state = -RT_ERROR;
goto __exit;
}
#endif
rt_err_t result;
// result = rt_mb_init(&tcpnet_rx_thread_mb, "trxmb",
// &tcpnet_rx_thread_mb_pool[0], sizeof(tcpnet_rx_thread_mb_pool)/4,
// RT_IPC_FLAG_FIFO);
// RT_ASSERT(result == RT_EOK);
#ifdef RT_USING_RL_TCPnet
state = rt_stm32_eth_init();
if(state != RT_EOK){
return state;
}
#endif
result = rt_event_init(&event, "event", RT_IPC_FLAG_FIFO);
if (result != RT_EOK)
{
rt_kprintf("init event failed.\n");
state = -RT_ERROR;
}
// result = rt_thread_init(&tcpnet_rx_thread, "trx", tcpnet_rx_thread_entry, RT_NULL,
// &tcpnet_rx_thread_stack[0], sizeof(tcpnet_rx_thread_stack),
// RT_THREAD_PRIORITY_MAX - 5, 16);
// RT_ASSERT(result == RT_EOK);
// result = rt_thread_startup(&tcpnet_rx_thread);
/* start phy monitor */
rt_thread_t tid;
tid = rt_thread_create("phy",
phy_monitor_thread_entry,
RT_NULL,
1024,
RT_THREAD_PRIORITY_MAX - 2,
2);
if (tid != RT_NULL)
{
rt_thread_startup(tid);
}
else
{
state = -RT_ERROR;
}
rt_thread_init(&main_TCPnet,
"thread_main_TCPnet",
thread_main_TCPnet,
RT_NULL,
&main_TCPnet_stack[0],
sizeof(main_TCPnet_stack),
THREAD_PRIORITY - 1, THREAD_TIMESLICE);
rt_thread_startup(&main_TCPnet);
rt_thread_init(&TCP_time,
"thread_TCP_timeTick",
thread_TCP_timeTick,
RT_NULL,
&TCP_time_stack[0],
sizeof(TCP_time_stack),
THREAD_PRIORITY, THREAD_TIMESLICE);
rt_thread_startup(&TCP_time);
__exit:
if (state != RT_EOK)
{
if (Rx_Buff)
{
rt_free(Rx_Buff);
}
if (Tx_Buff)
{
rt_free(Tx_Buff);
}
if (DMARxDscrTab)
{
rt_free(DMARxDscrTab);
}
if (DMATxDscrTab)
{
rt_free(DMATxDscrTab);
}
}
return state;
}
接着是send_frame函数
void send_frame (OS_FRAME *frame)
{
HAL_StatusTypeDef state;
rt_uint32_t i;
__IO ETH_DMADescTypeDef *DmaTxDesc;
rt_uint8_t *buffer = (rt_uint8_t *)(EthHandle.TxDesc->Buffer1Addr);
rt_uint32_t framelength = 0;
rt_uint32_t bufferoffset = 0;
rt_uint32_t byteslefttocopy = 0;
rt_uint32_t payloadoffset = 0;
DmaTxDesc = EthHandle.TxDesc;
bufferoffset = 0;
// LOG_D("%s\r\n",__func__);
/* copy frame from pbufs to driver buffers */
for (;;)
{
if ((DmaTxDesc->Status & ETH_DMATXDESC_OWN) != (uint32_t)RESET){
LOG_D("buffer not valid");
goto error;
}
/* Get bytes in current lwIP buffer */
byteslefttocopy = frame->length;
payloadoffset = 0;
/* Check if the length of data to copy is bigger than Tx buffer size*/
while ((byteslefttocopy + bufferoffset) > ETH_TX_BUF_SIZE)
{
/* Copy data to Tx buffer*/
memcpy((uint8_t *)((uint8_t *)buffer + bufferoffset), (uint8_t *)((uint8_t *)frame->data + payloadoffset), (ETH_TX_BUF_SIZE - bufferoffset));
/* Point to next descriptor */
DmaTxDesc = (ETH_DMADescTypeDef *)(DmaTxDesc->Buffer2NextDescAddr);
/* Check if the buffer is available */
if ((DmaTxDesc->Status & ETH_DMATXDESC_OWN) != (uint32_t)RESET)
{
LOG_E("dma tx desc buffer is not valid");
goto error;
}
buffer = (uint8_t *)(DmaTxDesc->Buffer1Addr);
byteslefttocopy = byteslefttocopy - (ETH_TX_BUF_SIZE - bufferoffset);
payloadoffset = payloadoffset + (ETH_TX_BUF_SIZE - bufferoffset);
framelength = framelength + (ETH_TX_BUF_SIZE - bufferoffset);
bufferoffset = 0;
}
/* Copy the remaining bytes */
memcpy((uint8_t *)((uint8_t *)buffer + bufferoffset), (uint8_t *)((uint8_t *)frame->data + payloadoffset), byteslefttocopy);
bufferoffset = bufferoffset + byteslefttocopy;
framelength = framelength + byteslefttocopy;
break;
}
#ifdef ETH_TX_DUMP
dump_hex(buffer, p->tot_len);
#endif
/* Prepare transmit descriptors to give to DMA */
/* TODO Optimize data send speed*/
LOG_D("%s lenth :%d", __func__,framelength);
for(i=0;i<1000;i++);
/* wait for unlocked */
while (EthHandle.Lock == HAL_LOCKED){
LOG_I("%s waitting",__func__);
};
state = HAL_ETH_TransmitFrame(&EthHandle, framelength);
if (state != HAL_OK)
{
LOG_E("eth transmit frame faild: %d", state);
}
rt_event_send(&event, EVENT_MAIN);
error:
/* When Transmit Underflow flag is set, clear it and issue a Transmit Poll Demand to resume transmission */
if ((EthHandle.Instance->DMASR & ETH_DMASR_TUS) != (uint32_t)RESET)
{
/* Clear TUS ETHERNET DMA flag */
EthHandle.Instance->DMASR = ETH_DMASR_TUS;
/* Resume DMA transmission*/
EthHandle.Instance->DMATPDR = 0;
}
}
然后是中断接受函数HAL_ETH_RxCpltCallback
void HAL_ETH_RxCpltCallback(ETH_HandleTypeDef *heth)
{
#ifdef RT_USING_LWIP
rt_err_t result;
result = eth_device_ready(&(stm32_eth_device.parent));
if (result != RT_EOK)
LOG_I("RxCpltCallback err = %d", result);
#endif
#ifdef RT_USING_RL_TCPnet
OS_FRAME *frame;
while(ETH_GetRxPktSize(heth->RxDesc))
{
// rt_mb_send(&tcpnet_rx_thread_mb, 0);
HAL_StatusTypeDef state;
uint16_t len = 0;
uint8_t *buffer;
__IO ETH_DMADescTypeDef *dmarxdesc;
uint32_t bufferoffset = 0;
uint32_t payloadoffset = 0;
uint32_t byteslefttocopy = 0;
volatile uint32_t i = 0;
/* Get received frame */
state = HAL_ETH_GetReceivedFrame_IT(&EthHandle);
if (state != HAL_OK)
{
LOG_D("receive frame faild");
}
/* Obtain the size of the packet and put it into the "len" variable. */
len = EthHandle.RxFrameInfos.length;
buffer = (uint8_t *)EthHandle.RxFrameInfos.buffer;
LOG_D("receive frame len : %d", len);
if (len > 0)
{
/* We allocate a pbuf chain of pbufs from the Lwip buffer pool */
frame = alloc_mem (len | 0x80000000);
}
#ifdef ETH_RX_DUMP
dump_hex(buffer, p->tot_len);
#endif
// for(i=0;i<5000;i++);
if (frame != NULL)
{
dmarxdesc = EthHandle.RxFrameInfos.FSRxDesc;
bufferoffset = 0;
for (;;)
{
byteslefttocopy = frame->length;
payloadoffset = 0;
/* Check if the length of bytes to copy in current pbuf is bigger than Rx buffer size*/
while ((byteslefttocopy + bufferoffset) > ETH_RX_BUF_SIZE)
{
/* Copy data to pbuf */
memcpy((uint8_t *)((uint8_t *)frame->data + payloadoffset), (uint8_t *)((uint8_t *)buffer + bufferoffset), (ETH_RX_BUF_SIZE - bufferoffset));
/* Point to next descriptor */
dmarxdesc = (ETH_DMADescTypeDef *)(dmarxdesc->Buffer2NextDescAddr);
buffer = (uint8_t *)(dmarxdesc->Buffer1Addr);
byteslefttocopy = byteslefttocopy - (ETH_RX_BUF_SIZE - bufferoffset);
payloadoffset = payloadoffset + (ETH_RX_BUF_SIZE - bufferoffset);
bufferoffset = 0;
}
/* Copy remaining data in pbuf */
memcpy((uint8_t *)((uint8_t *)frame->data + payloadoffset), (uint8_t *)((uint8_t *)buffer + bufferoffset), byteslefttocopy);
bufferoffset = bufferoffset + byteslefttocopy;
put_in_queue (frame);
break;
}
}else{
free_mem(frame);
return ;
}
/* Release descriptors to DMA */
/* Point to first descriptor */
dmarxdesc = EthHandle.RxFrameInfos.FSRxDesc;
/* Set Own bit in Rx descriptors: gives the buffers back to DMA */
for (i = 0; i < EthHandle.RxFrameInfos.SegCount; i++)
{
dmarxdesc->Status |= ETH_DMARXDESC_OWN;
dmarxdesc = (ETH_DMADescTypeDef *)(dmarxdesc->Buffer2NextDescAddr);
}
/* Clear Segment_Count */
EthHandle.RxFrameInfos.SegCount = 0;
/* When Rx Buffer unavailable flag is set: clear it and resume reception */
if ((EthHandle.Instance->DMASR & ETH_DMASR_RBUS) != (uint32_t)RESET)
{
/* Clear RBUS ETHERNET DMA flag */
EthHandle.Instance->DMASR = ETH_DMASR_RBUS;
/* Resume DMA reception */
EthHandle.Instance->DMARPDR = 0;
}
rt_event_send(&event, EVENT_MAIN);
}
#endif
}
在init_ethernet函数中，创建了两个线程，用于运行RL-TCPnet的时基和协议栈（基于rtt的事件驱动）。
移植完成后，下载到开发板中测试ftpserver功能，效果如下：
可以看到，速度可以达到2MB/s左右。
至此，移植完成！！！
标签：rt,RT,thread,TCPnet,uint8,stm32,ETH,eth 来源： https://blog.csdn.net/lz_kwok/article/details/105772955