[兆易GD32H759I-EVAL]8.熟悉ENET接口，通过移植lwip协议，实现TCPUDP通讯功能

xld0932

[兆易GD32H759I-EVAL]8.熟悉ENET接口，通过移植lwip协议，实现TCPUDP通讯功能 [复制链接]

1.以太网（ENET）

GD32H759系列MCU带有1~2路以太网接口，该以太网模块包含两个10/100Mbps以太网MAC（媒体访问控制器），采用DMA优化数据帧的发送与接收性能，支持MII（媒体独立接口）与RMII（简化的媒体独立接口）两种与物理层(PHY)通讯的标准接口，实现以太网数据帧的发送与接收。以太网模块遵守IEEE 802.3-2002标准和IEEE 1588-2008标准。主要特性如下：

MAC特性

支持10Mbps或100Mbps数据传输速率；
支持MII和RMII接口；
支持调试用回环模式；
支持符合CSMA/CD协议的半双工背压通讯；
支持符合IEEE 802.3x的流控通讯。在当前帧发送完毕后，根据接收的暂停帧中暂停时间延迟发送。在全双工/半双工模式下， MAC根据RxFIFO的填充程度自动发送暂停帧/背压信号；
支持符合IEEE 802.3x的全双工流控通讯，当输入流控信号失效时，自动发送零时间片暂停帧。支持符合IEEE 802.3x的半双工流控通讯，支持根据RxFIFO的填充程度（直通模式）自动发送背压信号；
可选择在发送操作时自动生成校验/填充位；
可选择在接收操作时自动去除校验/填充位；
帧长度可配置；
帧间隙可配置；
支持多种模式的接收过滤；
支持检测接收帧的IEEE 802.1Q VLAN标签；
支持强制网络统计标准（RFC2819/RFC2665）；
支持两种唤醒帧检测： LAN远程唤醒帧和AMD的Magic PacketTM帧；
支持校验和检查（IPv4报头， IPv4或IPv6数据格式封装的TCP、 UDP或ICMP）；
支持IEEE 1588-2008标准定义的以太网帧时间戳，并将其按64位记录于帧状态中；
相互独立的两个FIFO分别用于发送与接收；
在延迟冲突、过度冲突、过度顺延和下溢情况下丢弃帧；
帧传输时，支持存储转发模式下的硬件校验和的计算和插入。

DMA特性

支持环结构或链结构两种形式的描述符列表；
每个描述符可以传输最高为8192字节的数据；
中断可配置，适用于多种工作状态；
支持轮询或固定优先级两种方式仲裁DMA发送和接收控制器的请求。

PTP特性

支持符合IEEE1588的时间同步功能；
支持粗/精调两种校正方法；输出秒脉冲；
达到预设目标时间时触发中断。

2.以太网模块框图

3.搭建硬件环境

使用一个交换机一个端口连接到路由器上，一个端口连接到GD32H759I-EVAL开发板的以太网接口上，给交换机供电；将GD32H759I-EVAL开发板上关于ENET功能的跳帽设置正确。

4.实现功能

基于官网提供的例程熟悉ENET配置，熟悉Lwip移植和TCP/UDP通讯功能的实现。

5.程序设计

5.1.ENET外设配置

#include "gd32h7xx_enet.h"
#include "gd32h7xx_enet_eval.h"
#include "main.h"

const uint8_t gd32_str[] =
{
    "\r\n############ Welcome GigaDevice ############\r\n"
};
static __IO uint32_t enet_init_status = 0;

static void enet_gpio_config(void);
static void enet_mac_dma_config(void);

#ifdef USE_ENET_INTERRUPT
static void nvic_configuration(void);
#endif

void enet_system_setup(void)
{
    uint32_t ahb_frequency = 0;

#ifdef USE_ENET_INTERRUPT
    nvic_configuration();
#endif

    enet_gpio_config();

    enet_mac_dma_config();

    if (0 == enet_init_status)
    {
        while (1)
        {
        }
    }

#ifdef USE_ENET_INTERRUPT
#ifdef USE_ENET0
    enet_interrupt_enable(ENET0, ENET_DMA_INT_NIE);
    enet_interrupt_enable(ENET0, ENET_DMA_INT_RIE);
#ifdef SELECT_DESCRIPTORS_ENHANCED_MODE
    enet_desc_select_enhanced_mode(ENET0);
#endif
#endif
#ifdef USE_ENET1
    enet_interrupt_enable(ENET1, ENET_DMA_INT_NIE);
    enet_interrupt_enable(ENET1, ENET_DMA_INT_RIE);

#ifdef SELECT_DESCRIPTORS_ENHANCED_MODE
    enet_desc_select_enhanced_mode(ENET1);
#endif
#endif
#endif

    systick_clksource_set(SYSTICK_CLKSOURCE_CKSYS);

    ahb_frequency = rcu_clock_freq_get(CK_AHB);
    SysTick_Config(ahb_frequency / 100);
}

static void enet_mac_dma_config(void)
{
    ErrStatus reval_state = ERROR;

#ifdef USE_ENET0
    rcu_periph_clock_enable(RCU_ENET0);
    rcu_periph_clock_enable(RCU_ENET0TX);
    rcu_periph_clock_enable(RCU_ENET0RX);

    enet_deinit(ENET0);

    reval_state = enet_software_reset(ENET0);

    if (ERROR == reval_state)
    {
        while (1)
        {
        }
    }

#ifdef CHECKSUM_BY_HARDWARE
    enet_init_status = enet_init(ENET0, ENET_AUTO_NEGOTIATION, ENET_AUTOCHECKSUM_DROP_FAILFRAMES, ENET_BROADCAST_FRAMES_PASS);
#else
    enet_init_status = enet_init(ENET0, ENET_AUTO_NEGOTIATION, ENET_NO_AUTOCHECKSUM, ENET_BROADCAST_FRAMES_PASS);
#endif
#endif

#ifdef USE_ENET1
    rcu_periph_clock_enable(RCU_ENET1);
    rcu_periph_clock_enable(RCU_ENET1TX);
    rcu_periph_clock_enable(RCU_ENET1RX);

    enet_deinit(ENET1);

    reval_state = enet_software_reset(ENET1);

    if (ERROR == reval_state)
    {
        while (1)
        {
        }
    }

#ifdef CHECKSUM_BY_HARDWARE
    enet_init_status = enet_init(ENET1, ENET_AUTO_NEGOTIATION, ENET_AUTOCHECKSUM_DROP_FAILFRAMES, ENET_BROADCAST_FRAMES_PASS);
#else
    enet_init_status = enet_init(ENET1, ENET_AUTO_NEGOTIATION, ENET_NO_AUTOCHECKSUM, ENET_BROADCAST_FRAMES_PASS);
#endif
#endif
}

#ifdef USE_ENET_INTERRUPT
static void nvic_configuration(void)
{
    nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2);

#ifdef USE_ENET0
    nvic_irq_enable(ENET0_IRQn, 0, 0);
#endif

#ifdef USE_ENET1
    nvic_irq_enable(ENET1_IRQn, 0, 0);
#endif
}

#endif

static void enet_gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_GPIOD);
    rcu_periph_clock_enable(RCU_GPIOE);
    rcu_periph_clock_enable(RCU_GPIOG);
    rcu_periph_clock_enable(RCU_GPIOH);

    gpio_af_set(GPIOA, GPIO_AF_0, GPIO_PIN_8);
    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_8);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_8);

    rcu_periph_clock_enable(RCU_SYSCFG);

#ifdef MII_MODE
#ifdef PHY_CLOCK_MCO
    rcu_ckout0_config(RCU_CKOUT0SRC_HXTAL, RCU_CKOUT0_DIV1);
#endif

#ifdef USE_ENET0
    syscfg_enet_phy_interface_config(ENET0, SYSCFG_ENET_PHY_MII);
#endif

#ifdef USE_ENET1
    syscfg_enet_phy_interface_config(ENET1, SYSCFG_ENET_PHY_MII);
#endif
#elif defined RMII_MODE
    rcu_ckout0_config(RCU_CKOUT0SRC_PLL0P, RCU_CKOUT0_DIV12);

#ifdef USE_ENET0
    syscfg_enet_phy_interface_config(ENET0, SYSCFG_ENET_PHY_RMII);
#endif

#ifdef USE_ENET1
    syscfg_enet_phy_interface_config(ENET1, SYSCFG_ENET_PHY_RMII);
#endif
#endif

#ifdef USE_ENET0
#ifdef MII_MODE

    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_1);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_1);

    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_2);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_2);

    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_7);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_7);

    gpio_af_set(GPIOA, GPIO_AF_11, GPIO_PIN_1);
    gpio_af_set(GPIOA, GPIO_AF_11, GPIO_PIN_2);
    gpio_af_set(GPIOA, GPIO_AF_11, GPIO_PIN_7);

    gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_8);
    gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_8);

    gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_10);
    gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_10);

    gpio_af_set(GPIOB, GPIO_AF_11, GPIO_PIN_8);
    gpio_af_set(GPIOB, GPIO_AF_11, GPIO_PIN_10);

    gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_1);
    gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_1);

    gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_2);
    gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_2);

    gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_3);
    gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_3);

    gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_4);
    gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_4);

    gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_5);
    gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_5);

    gpio_af_set(GPIOC, GPIO_AF_11, GPIO_PIN_1);
    gpio_af_set(GPIOC, GPIO_AF_11, GPIO_PIN_2);
    gpio_af_set(GPIOC, GPIO_AF_11, GPIO_PIN_3);
    gpio_af_set(GPIOC, GPIO_AF_11, GPIO_PIN_4);
    gpio_af_set(GPIOC, GPIO_AF_11, GPIO_PIN_5);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_2);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_2);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_3);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_3);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_6);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_6);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_7);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_7);

    gpio_af_set(GPIOH, GPIO_AF_11, GPIO_PIN_2);
    gpio_af_set(GPIOH, GPIO_AF_11, GPIO_PIN_3);
    gpio_af_set(GPIOH, GPIO_AF_11, GPIO_PIN_6);
    gpio_af_set(GPIOH, GPIO_AF_11, GPIO_PIN_7);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_11);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_11);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_13);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_13);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_14);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_14);

    gpio_af_set(GPIOG, GPIO_AF_11, GPIO_PIN_11);
    gpio_af_set(GPIOG, GPIO_AF_11, GPIO_PIN_13);
    gpio_af_set(GPIOG, GPIO_AF_11, GPIO_PIN_14);

    gpio_mode_set(GPIOD, GPIO_MODE_INPUT, GPIO_PUPD_NONE, GPIO_PIN_8);

#elif defined RMII_MODE

    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_1);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_1);

    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_2);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_2);

    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_7);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_7);

    gpio_af_set(GPIOA, GPIO_AF_11, GPIO_PIN_1);
    gpio_af_set(GPIOA, GPIO_AF_11, GPIO_PIN_2);
    gpio_af_set(GPIOA, GPIO_AF_11, GPIO_PIN_7);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_11);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_11);

    gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_12);
    gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_12);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_12);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_12);

    gpio_af_set(GPIOG, GPIO_AF_11, GPIO_PIN_11);
    gpio_af_set(GPIOB, GPIO_AF_11, GPIO_PIN_12);
    gpio_af_set(GPIOG, GPIO_AF_11, GPIO_PIN_12);

    gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_1);
    gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_1);

    gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_4);
    gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_4);

    gpio_mode_set(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_5);
    gpio_output_options_set(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_5);

    gpio_af_set(GPIOC, GPIO_AF_11, GPIO_PIN_1);
    gpio_af_set(GPIOC, GPIO_AF_11, GPIO_PIN_4);
    gpio_af_set(GPIOC, GPIO_AF_11, GPIO_PIN_5);

#endif
#endif

#ifdef USE_ENET1
#ifdef MII_MODE

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_6);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_6);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_7);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_7);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_8);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_8);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_9);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_9);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_10);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_10);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_11);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_11);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_12);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_12);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_13);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_13);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_14);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_14);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_15);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_15);

    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_6);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_7);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_8);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_9);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_10);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_11);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_12);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_13);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_14);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_15);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_6);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_6);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_9);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_9);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_11);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_11);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_12);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_12);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_13);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_13);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_14);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_14);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_15);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_15);

    gpio_af_set(GPIOG, GPIO_AF_6, GPIO_PIN_6);
    gpio_af_set(GPIOG, GPIO_AF_6, GPIO_PIN_9);
    gpio_af_set(GPIOG, GPIO_AF_6, GPIO_PIN_11);
    gpio_af_set(GPIOG, GPIO_AF_6, GPIO_PIN_12);
    gpio_af_set(GPIOG, GPIO_AF_6, GPIO_PIN_13);
    gpio_af_set(GPIOG, GPIO_AF_6, GPIO_PIN_14);
    gpio_af_set(GPIOG, GPIO_AF_6, GPIO_PIN_15);

    gpio_mode_set(GPIOE, GPIO_MODE_INPUT, GPIO_PUPD_NONE, GPIO_PIN_1);

#elif defined RMII_MODE

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_8);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_8);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_9);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_9);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_11);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_11);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_12);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_12);

    gpio_mode_set(GPIOH, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_14);
    gpio_output_options_set(GPIOH, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_14);

    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_8);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_9);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_11);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_12);
    gpio_af_set(GPIOH, GPIO_AF_6, GPIO_PIN_14);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_6);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_6);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_11);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_11);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_13);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_13);

    gpio_mode_set(GPIOG, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_14);
    gpio_output_options_set(GPIOG, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_14);

    gpio_af_set(GPIOG, GPIO_AF_6, GPIO_PIN_6);
    gpio_af_set(GPIOG, GPIO_AF_6, GPIO_PIN_11);
    gpio_af_set(GPIOG, GPIO_AF_6, GPIO_PIN_13);
    gpio_af_set(GPIOG, GPIO_AF_6, GPIO_PIN_14);
#endif
#endif
}

5.2.Lwip接口实现

#include "lwip/mem.h"
#include "netif/etharp.h"
#include "ethernetif.h"
#include "gd32h7xx_enet.h"
#include "main.h"
#include <string.h>

#define IFNAME0 'G'
#define IFNAME1 'D'

extern enet_descriptors_struct  rxdesc_tab[ENET_RXBUF_NUM], txdesc_tab[ENET_TXBUF_NUM];
extern uint8_t rx_buff[ENET_RXBUF_NUM][ENET_RXBUF_SIZE];
extern uint8_t tx_buff[ENET_TXBUF_NUM][ENET_TXBUF_SIZE];
extern enet_descriptors_struct  *dma_current_txdesc;
extern enet_descriptors_struct  *dma_current_rxdesc;
enet_descriptors_struct  ptp_txstructure[ENET_TXBUF_NUM];
enet_descriptors_struct  ptp_rxstructure[ENET_RXBUF_NUM];

static void low_level_init(struct netif *netif)
{
#ifdef CHECKSUM_BY_HARDWARE
    int i;
#endif
    netif->hwaddr_len = ETHARP_HWADDR_LEN;

    netif->hwaddr[0] = MAC_ADDR0;
    netif->hwaddr[1] = MAC_ADDR1;
    netif->hwaddr[2] = MAC_ADDR2;
    netif->hwaddr[3] = MAC_ADDR3;
    netif->hwaddr[4] = MAC_ADDR4;
    netif->hwaddr[5] = MAC_ADDR5;
#ifdef USE_ENET0
    enet_mac_address_set(ENET0, ENET_MAC_ADDRESS0, netif->hwaddr);
#endif

#ifdef USE_ENET1
    enet_mac_address_set(ENET1, ENET_MAC_ADDRESS0, netif->hwaddr);
#endif

    netif->mtu = 1500;

    netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;

#ifdef USE_ENET0
#ifdef SELECT_DESCRIPTORS_ENHANCED_MODE
    enet_ptp_enhanced_descriptors_chain_init(ENET0, ENET_DMA_TX);
    enet_ptp_enhanced_descriptors_chain_init(ENET0, ENET_DMA_RX);
#else
    enet_descriptors_chain_init(ENET0, ENET_DMA_TX);
    enet_descriptors_chain_init(ENET0, ENET_DMA_RX);
#endif
#endif

#ifdef USE_ENET1
#ifdef SELECT_DESCRIPTORS_ENHANCED_MODE
    enet_ptp_enhanced_descriptors_chain_init(ENET1, ENET_DMA_TX);
    enet_ptp_enhanced_descriptors_chain_init(ENET1, ENET_DMA_RX);
#else
    enet_descriptors_chain_init(ENET1, ENET_DMA_TX);
    enet_descriptors_chain_init(ENET1, ENET_DMA_RX);
#endif
#endif

    {
        int i;

        for (i = 0; i < ENET_RXBUF_NUM; i++)
        {
            enet_rx_desc_immediate_receive_complete_interrupt(&rxdesc_tab[i]);
        }
    }

#ifdef CHECKSUM_BY_HARDWARE
    for (i = 0; i < ENET_TXBUF_NUM; i++)
    {
        enet_transmit_checksum_config(&txdesc_tab[i], ENET_CHECKSUM_TCPUDPICMP_FULL);
    }
#endif

#ifdef USE_ENET0
    enet_enable(ENET0);
#endif

#ifdef USE_ENET1
    enet_enable(ENET1);
#endif
}

static err_t low_level_output(struct netif *netif, struct pbuf *p)
{
    struct pbuf *q;
    int framelength = 0;
    uint8_t *buffer;

    while ((uint32_t)RESET != (dma_current_txdesc->status & ENET_TDES0_DAV))
    {
    }

#ifdef USE_ENET0
    buffer = (uint8_t *)(enet_desc_information_get(ENET0, dma_current_txdesc, TXDESC_BUFFER_1_ADDR));
#endif

#ifdef USE_ENET1
    buffer = (uint8_t *)(enet_desc_information_get(ENET1, dma_current_txdesc, TXDESC_BUFFER_1_ADDR));
#endif

    for (q = p; q != NULL; q = q->next)
    {
        memcpy((uint8_t *)&buffer[framelength], q->payload, q->len);
        framelength = framelength + q->len;
    }

#ifdef USE_ENET0
#ifdef SELECT_DESCRIPTORS_ENHANCED_MODE
    ENET_NOCOPY_PTPFRAME_TRANSMIT_ENHANCED_MODE(ENET0, framelength, NULL);
#else
    ENET_NOCOPY_FRAME_TRANSMIT(ENET0, framelength);
#endif
#endif

#ifdef USE_ENET1
#ifdef SELECT_DESCRIPTORS_ENHANCED_MODE
    ENET_NOCOPY_PTPFRAME_TRANSMIT_ENHANCED_MODE(ENET1, framelength, NULL);
#else
    ENET_NOCOPY_FRAME_TRANSMIT(ENET1, framelength);
#endif
#endif

    return (ERR_OK);
}

static struct pbuf *low_level_input(struct netif *netif)
{
    struct pbuf *p, *q;
    u16_t len;
    int l = 0;
    uint8_t *buffer;

    p = NULL;

#ifdef USE_ENET0
    len    = enet_desc_information_get(ENET0, dma_current_rxdesc, RXDESC_FRAME_LENGTH);
    buffer = (uint8_t *)(enet_desc_information_get(ENET0, dma_current_rxdesc, RXDESC_BUFFER_1_ADDR));
#endif

#ifdef USE_ENET1
    len    = enet_desc_information_get(ENET1, dma_current_rxdesc, RXDESC_FRAME_LENGTH);
    buffer = (uint8_t *)(enet_desc_information_get(ENET1, dma_current_rxdesc, RXDESC_BUFFER_1_ADDR));
#endif

    p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);

    if (p != NULL)
    {
        for (q = p; q != NULL; q = q->next)
        {
            memcpy((uint8_t *)q->payload, (u8_t *)&buffer[l], q->len);
            l = l + q->len;
        }
    }

#ifdef USE_ENET0
#ifdef SELECT_DESCRIPTORS_ENHANCED_MODE
    ENET_NOCOPY_PTPFRAME_RECEIVE_ENHANCED_MODE(ENET0, NULL);
#else
    ENET_NOCOPY_FRAME_RECEIVE(ENET0);
#endif
#endif

#ifdef USE_ENET1
#ifdef SELECT_DESCRIPTORS_ENHANCED_MODE
    ENET_NOCOPY_PTPFRAME_RECEIVE_ENHANCED_MODE(ENET1, NULL);
#else
    ENET_NOCOPY_FRAME_RECEIVE(ENET1);
#endif
#endif

    return (p);
}

err_t ethernetif_input(struct netif *netif)
{
    err_t err;
    struct pbuf *p;

    p = low_level_input(netif);

    if (p == NULL)
    {
        return (ERR_MEM);
    }

    err = netif->input(p, netif);

    if (err != ERR_OK)
    {
        LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n"));
        pbuf_free(p);
        p = NULL;
    }

    return (err);
}

err_t ethernetif_init(struct netif *netif)
{
    LWIP_ASSERT("netif != NULL", (netif != NULL));

#if LWIP_NETIF_HOSTNAME
    netif->hostname = "Gigadevice.COM_lwip";
#endif

    netif->name[0]    = IFNAME0;
    netif->name[1]    = IFNAME1;
    netif->output     = etharp_output;
    netif->linkoutput = low_level_output;

    low_level_init(netif);

    return (ERR_OK);
}

5.3.网络配置

#include "lwip/mem.h"
#include "lwip/memp.h"
#include "lwip/tcp.h"
#include "lwip/udp.h"
#include "netif/etharp.h"
#include "lwip/dhcp.h"
#include "ethernetif.h"
#include "stdint.h"
#include "main.h"
#include "netconf.h"
#include <stdio.h>
#include "lwip/priv/tcp_priv.h"
#include "lwip/timeouts.h"

#define MAX_DHCP_TRIES        4

typedef enum
{
    DHCP_START = 0,
    DHCP_WAIT_ADDRESS,
    DHCP_ADDRESS_ASSIGNED,
    DHCP_TIMEOUT
} dhcp_state_enum;

#ifdef USE_DHCP
uint32_t dhcp_fine_timer   = 0;
uint32_t dhcp_coarse_timer = 0;
dhcp_state_enum dhcp_state = DHCP_START;

#endif

struct netif g_mynetif0, g_mynetif1;
uint32_t tcp_timer   = 0;
uint32_t arp_timer   = 0;
ip_addr_t ip_address =
{
    0
};

void lwip_dhcp_process_handle(void);
void lwip_netif_status_callback(struct netif *netif);

void lwip_stack_init(void)
{
    ip_addr_t ipaddr;
    ip_addr_t netmask;
    ip_addr_t gw;

    mem_init();

    memp_init();

#ifdef TIMEOUT_CHECK_USE_LWIP
    sys_timeouts_init();
#endif

#ifdef USE_DHCP
    ipaddr.addr  = 0;
    netmask.addr = 0;
    gw.addr = 0;
#else
    IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
    IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
    IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
#endif

#ifdef USE_ENET0
    netif_add(&g_mynetif0, &ipaddr, &netmask, &gw, NULL, ðernetif_init, ðernet_input);

    netif_set_default(&g_mynetif0);
    netif_set_status_callback(&g_mynetif0, lwip_netif_status_callback);

    netif_set_up(&g_mynetif0);
#endif

#ifdef USE_ENET1
    netif_add(&g_mynetif1, &ipaddr, &netmask, &gw, NULL, ðernetif_init, ðernet_input);

    netif_set_default(&g_mynetif1);
    netif_set_status_callback(&g_mynetif1, lwip_netif_status_callback);

    netif_set_up(&g_mynetif1);
#endif
}

void lwip_pkt_handle0(void)
{
    ethernetif_input(&g_mynetif0);
}

void lwip_pkt_handle1(void)
{
    ethernetif_input(&g_mynetif1);
}

void lwip_periodic_handle(__IO uint32_t localtime)
{
#if LWIP_TCP
    if (localtime - tcp_timer >= TCP_TMR_INTERVAL)
    {
        tcp_timer = localtime;
        tcp_tmr();
    }
#endif

    if ((localtime - arp_timer) >= ARP_TMR_INTERVAL)
    {
        arp_timer = localtime;
        etharp_tmr();
    }

#ifdef USE_DHCP
    if (localtime - dhcp_fine_timer >= DHCP_FINE_TIMER_MSECS)
    {
        dhcp_fine_timer = localtime;
        dhcp_fine_tmr();

        if ((DHCP_ADDRESS_ASSIGNED != dhcp_state) && (DHCP_TIMEOUT != dhcp_state))
        {
            lwip_dhcp_process_handle();
        }
    }

    if (localtime - dhcp_coarse_timer >= DHCP_COARSE_TIMER_MSECS)
    {
        dhcp_coarse_timer = localtime;
        dhcp_coarse_tmr();
    }
#endif
}

#ifdef USE_DHCP
void lwip_dhcp_process_handle(void)
{
    ip_addr_t ipaddr;
    ip_addr_t netmask;
    ip_addr_t gw
    ;

#ifdef USE_ENET0
    struct dhcp *dhcp_client0;
#endif

#ifdef USE_ENET1
    struct dhcp *dhcp_client1;
#endif

#ifdef USE_ENET0
    switch (dhcp_state)
    {
        case DHCP_START:
            dhcp_start(&g_mynetif0);

            dhcp_state = DHCP_WAIT_ADDRESS;
            break;

        case DHCP_WAIT_ADDRESS:
            ip_address.addr = g_mynetif0.ip_addr.addr;

            if (0 != ip_address.addr)
            {
                dhcp_state = DHCP_ADDRESS_ASSIGNED;

                printf("\r\nDHCP -- eval board ip address: %d.%d.%d.%d \r\n",
                       ip4_addr1_16(&ip_address), ip4_addr2_16(&ip_address),
                       ip4_addr3_16(&ip_address), ip4_addr4_16(&ip_address));
            }
            else
            {
                dhcp_client0 = netif_dhcp_data(&g_mynetif0);

                if (dhcp_client0->tries > MAX_DHCP_TRIES)
                {
                    dhcp_state = DHCP_TIMEOUT;

                    dhcp_stop(&g_mynetif0);

                    IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
                    IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
                    IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
                    netif_set_addr(&g_mynetif0, &ipaddr, &netmask, &gw);
                }
            }

            break;

        default:
            break;
    }
#endif

#ifdef USE_ENET1
    switch (dhcp_state)
    {
        case DHCP_START:
            dhcp_start(&g_mynetif1);

            dhcp_state = DHCP_WAIT_ADDRESS;
            break;

        case DHCP_WAIT_ADDRESS:
            ip_address.addr = g_mynetif1.ip_addr.addr;

            if (0 != ip_address.addr)
            {
                dhcp_state = DHCP_ADDRESS_ASSIGNED;

                printf("\r\nDHCP -- eval board ip address: %d.%d.%d.%d \r\n",
                       ip4_addr1_16(&ip_address), ip4_addr2_16(&ip_address),
                       ip4_addr3_16(&ip_address), ip4_addr4_16(&ip_address));
            }
            else
            {
                dhcp_client1 = netif_dhcp_data(&g_mynetif1);

                if (dhcp_client1->tries > MAX_DHCP_TRIES)
                {
                    dhcp_state = DHCP_TIMEOUT;

                    dhcp_stop(&g_mynetif1);

                    IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
                    IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
                    IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
                    netif_set_addr(&g_mynetif1, &ipaddr, &netmask, &gw);
                }
            }

            break;

        default:
            break;
    }
#endif
}

#endif

unsigned long sys_now(void)
{
    extern volatile unsigned int g_localtime;

    return (g_localtime);
}

5.4.TCP/UDP接口

#include "tcp_client.h"
#include "lwip/tcp.h"
#include "lwip/memp.h"
#include <string.h>
#include <stdio.h>
#include "gd32h7xx.h"
#include "main.h"

#define MAX_BUF_SIZE    50

struct recev_packet
{
    int  length;
    char bytes[MAX_BUF_SIZE];
};

static err_t tcp_client_connected(void *arg, struct tcp_pcb *pcb, err_t err);
static err_t tcp_client_recv(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err);

static err_t tcp_client_recv(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
{
    struct pbuf *q;
    struct recev_packet *recev_packet = (struct recev_packet *)arg;
    int buf_full;
    char *c;
    int i;

    if (p != NULL)
    {
        tcp_recved(pcb, p->tot_len);

        if (!recev_packet)
        {
            pbuf_free(p);
            return (ERR_ARG);
        }

        buf_full = 0;

        for (q = p; q != NULL; q = q->next)
        {
            c = q->payload;

            for (i = 0; i < q->len && !buf_full; i++)
            {
                if (recev_packet->length < MAX_BUF_SIZE)
                {
                    recev_packet->bytes[recev_packet->length] = c[i];
                    recev_packet->length++;
                }
                else
                {
                    buf_full = 1;
                }
            }
        }

        tcp_write(pcb, recev_packet->bytes, recev_packet->length, 1);
        recev_packet->length = 0;

        pbuf_free(p);
    }
    else if (ERR_OK == err)
    {
        mem_free(recev_packet);
        return (tcp_close(pcb));
    }

    return (ERR_OK);
}

static err_t tcp_client_connected(void *arg, struct tcp_pcb *pcb, err_t err)
{
    tcp_arg(pcb, mem_calloc(sizeof(struct recev_packet), 1));

    tcp_recv(pcb, tcp_client_recv);

    return (ERR_OK);
}

void tcp_client_init(void)
{
    struct tcp_pcb *pcb;
    ip_addr_t ipaddr;

    IP4_ADDR(&ipaddr, IP_S_ADDR0, IP_S_ADDR1, IP_S_ADDR2, IP_S_ADDR3);

    pcb = tcp_new();

    if (ERR_USE != tcp_bind(pcb, IP_ADDR_ANY, 10260))
    {
        tcp_connect(pcb, &ipaddr, 10260, tcp_client_connected);
    }
    else
    {
        printf("connect is still alive \r\n ");
        memp_free(MEMP_TCP_PCB, pcb);
    }
}


#include "udp_echo.h"
#include "lwip/udp.h"
#include <string.h>
#include <stdio.h>
#include "gd32h7xx.h"

static void udp_echo_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port);

static void udp_echo_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
{
    ip_addr_t destaddr = *addr;

    if (p != NULL)
    {
        udp_sendto(pcb, p, &destaddr, port);

        pbuf_free(p);
    }
}

void udp_echo_init(void)
{
    struct udp_pcb *udppcb;

    udppcb = udp_new();

    udp_bind(udppcb, IP_ADDR_ANY, 1025);
    udp_recv(udppcb, udp_echo_recv, NULL);
}

5.5.TCP/UDP应用实现

#include "hello_gigadevice.h"
#include "lwip/tcp.h"
#include <string.h>
#include <stdio.h>
#include "gd32h7xx.h"

#define GREETING    \
                         "\n\r======= HelloGigaDevice =======\
                          \n\r== GD32 ==\
                          \n\r== Telnet SUCCESS==\
                          \n\rHello. What is your name?\r\n"
#define HELLO            "\n\rGigaDevice Hello "
#define MAX_NAME_SIZE    32

extern const uint8_t gd32_str[];
struct name
{
    int  length;
    char bytes[MAX_NAME_SIZE];
};

static err_t hello_gigadevice_recv(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err);
static err_t hello_gigadevice_accept(void *arg, struct tcp_pcb *pcb, err_t err);
static void hello_gigadevice_conn_err(void *arg, err_t err);

static err_t hello_gigadevice_recv(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
{
    struct pbuf *q;
    struct name *name = (struct name *)arg;
    int done;
    char *c;
    int i;

    if (p != NULL)
    {
        tcp_recved(pcb, p->tot_len);

        if (!name)
        {
            pbuf_free(p);
            return (ERR_ARG);
        }

        done = 0;

        for (q = p; q != NULL; q = q->next)
        {
            c = q->payload;

            for (i = 0; i < q->len && !done; i++)
            {
                done = ((c[i] == '\r') || (c[i] == '\n'));

                if (name->length < MAX_NAME_SIZE)
                {
                    name->bytes[name->length++] = c[i];
                }
            }
        }

        if (done)
        {
            if ((name->bytes[name->length - 2] != '\r') || (name->bytes[name->length - 1] != '\n'))
            {
                if (((name->bytes[name->length - 1] == '\r')  ||
                     (name->bytes[name->length - 1] == '\n')) &&
                     (name->length + 1 <= MAX_NAME_SIZE))
                {
                    name->length += 1;
                }
                else if (name->length + 2 <= MAX_NAME_SIZE)
                {
                    name->length += 2;
                }
                else
                {
                    name->length = MAX_NAME_SIZE;
                }

                name->bytes[name->length - 2] = '\r';
                name->bytes[name->length - 1] = '\n';
            }

            tcp_write(pcb, HELLO, strlen(HELLO), 1);
            tcp_write(pcb, name->bytes, name->length, TCP_WRITE_FLAG_COPY);
            printf("\n\rGigaDevice\n\rTelnet %s %s", HELLO, name->bytes);
            name->length = 0;
        }

        pbuf_free(p);
    }
    else if (err == ERR_OK)
    {
        mem_free(name);
        return (tcp_close(pcb));
    }

    return (ERR_OK);
}

static err_t hello_gigadevice_accept(void *arg, struct tcp_pcb *pcb, err_t err)
{
    u32_t ipaddress;
    u8_t iptxt[50];
    u8_t iptab[4];

    ipaddress = pcb->remote_ip.addr;
    printf("\n\rTelnet hello_gigadevice_accept:%d.%d.%d.%d  %s",
            (u8_t)(ipaddress),
            (u8_t)(ipaddress >> 8),
            (u8_t)(ipaddress >> 16),
            (u8_t)(ipaddress >> 24), GREETING);

    iptab[0] = (u8_t)(ipaddress >> 24);
    iptab[1] = (u8_t)(ipaddress >> 16);
    iptab[2] = (u8_t)(ipaddress >> 8);
    iptab[3] = (u8_t)(ipaddress);

    sprintf((char *)iptxt, "Telnet:%d.%d.%d.%d   ", iptab[3], iptab[2], iptab[1], iptab[0]);
    printf("%s\r\n", iptxt);

    tcp_arg(pcb, mem_calloc(sizeof(struct name), 1));

    tcp_err(pcb, hello_gigadevice_conn_err);
    tcp_recv(pcb, hello_gigadevice_recv);

    tcp_write(pcb, iptxt, strlen((char *)iptxt), 1);
    sprintf((char *)iptxt, "You telnet computer's IP is: %d.%d.%d.%d\n", iptab[3], iptab[2], iptab[1], iptab[0]);
    printf("%s\r\n", iptxt);
    tcp_write(pcb, gd32_str, strlen((char *)gd32_str), 1);
    tcp_write(pcb, GREETING, strlen(GREETING), 1);

    return (ERR_OK);
}

void hello_gigadevice_init(void)
{
    struct tcp_pcb *pcb;

    pcb = tcp_new();

    tcp_bind(pcb, IP_ADDR_ANY, 8000);

    pcb = tcp_listen(pcb);

    tcp_accept(pcb, hello_gigadevice_accept);
}

static void hello_gigadevice_conn_err(void *arg, err_t err)
{
    struct name *name;

    name = (struct name *)arg;

    mem_free(name);
}

5.6.网络配置信息

#ifndef MAIN_H
#define MAIN_H

#include "gd32h7xx.h"
#include "stdint.h"
#include "gd32h7xx_enet_eval.h"

//#define USE_DHCP    /* enable DHCP, if disabled static address is used */

//#define USE_ENET_INTERRUPT

/*The USE_ENET0 and USE_ENET1 macros cannot be opened at the same time*/
#define USE_ENET0
//#define USE_ENET1

//#define TIMEOUT_CHECK_USE_LWIP

/* MAC address: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
#define MAC_ADDR0   4
#define MAC_ADDR1   0xA
#define MAC_ADDR2   0xD
#define MAC_ADDR3   0xE
#define MAC_ADDR4   0xD
#define MAC_ADDR5   6

/* static IP address: IP_ADDR0.IP_ADDR1.IP_ADDR2.IP_ADDR3 */
#define IP_ADDR0        192
#define IP_ADDR1        168
#define IP_ADDR2        124
#define IP_ADDR3        210

/* remote IP address: IP_S_ADDR0.IP_S_ADDR1.IP_S_ADDR2.IP_S_ADDR3 */
#define IP_S_ADDR0      192
#define IP_S_ADDR1      168
#define IP_S_ADDR2      124
#define IP_S_ADDR3      17
 
/* net mask */
#define NETMASK_ADDR0   255
#define NETMASK_ADDR1   255
#define NETMASK_ADDR2   255
#define NETMASK_ADDR3   0

/* gateway address */
#define GW_ADDR0        192
#define GW_ADDR1        168
#define GW_ADDR2        124
#define GW_ADDR3        1

/* MII and RMII mode selection */
#define RMII_MODE  // user have to provide the 50 MHz clock by soldering a 50 MHz oscillator
//#define MII_MODE

/* clock the PHY from external 25MHz crystal (only for MII mode) */
#ifdef  MII_MODE
#define PHY_CLOCK_MCO
#endif

/* function declarations */
/* updates the system local time */
void time_update(void);
/* insert a delay time */
void delay_10ms(uint32_t ncount);

#endif /* MAIN_H */

6.运行结果

6.1.硬件环境连接完成后，下载程序到开发板运行，通过电脑终端命令，获取当前电脑的IP地址信息，PING通GD32H759I-EVAL开发板。

6.2.电脑作为TCP Client端，GD32H759I-EVAL开发板作为TCP Server端，进行连接后，运行测试结果如下：

6.3.电脑作为TCP Server端，GD32H759I-EVAL开发板作为TCP Client端，进行连接后，检测到GD32H759I-EVAL开发板Client上线，Server端和Client端互发消息成功，运行测试结果如下：

6.4.电脑和GD32H759I-EVAL开发板都使用UDP进行通讯，配置电脑的IP地址及端口号之后，向指定的GD32H759I-EVAL开发板的IP地址和端口号发送数据，并接收到了GD32H759I-EVAL开发板的回复消息，测试运行结果如下所示：

7.附件

软件工程：

RAW_TCP_UDP.zip (10.62 MB, 下载次数: 0)

lugl4313820

大佬，你什么都会呀，前端后端都能整出大动静来，点赞点赞！

xld0932

[兆易GD32H759I-EVAL]8.熟悉ENET接口，通过移植lwip协议，实现TCPUDP通讯功能 [复制链接]

最新回复

赞赏