LWIP下的NETCONN UDP：你知道如何实现吗？

#ifndef FREERTOS_CONFIG_H

#define FREERTOS_CONFIG_H

/*-----------------------------------------------------------

* Application specific definitions.

*

* These definitions should be adjusted for your particular hardware and

* application requirements.

*

* THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE

* FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE.

*

* See http://www.freertos.org/a00110.html

*----------------------------------------------------------*/

/* Ensure stdint is only used by the compiler, and not the assembler. */

#if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)

    #include <stdint.h>

    extern uint32_t SystemCoreClock;

#endif

#define configUSE_PREEMPTION            1

#define configUSE_IDLE_HOOK             0//1

#define configUSE_TICK_HOOK             0//1

#define configCPU_CLOCK_HZ              ( SystemCoreClock )

#define configTICK_RATE_HZ              ( ( TickType_t ) 100 )

#define configMAX_PRIORITIES            ( 5 )

#define configMINIMAL_STACK_SIZE        ( ( unsigned short ) 130 )

#define configTOTAL_HEAP_SIZE           ( ( size_t ) ( 20 * 1024 ) )

#define configMAX_TASK_NAME_LEN         ( 10 )

#define configUSE_TRACE_FACILITY        1

#define configUSE_16_BIT_TICKS          0

#define configIDLE_SHOULD_YIELD         1

#define configUSE_MUTEXES               1

#define configQUEUE_REGISTRY_SIZE       8

#define configCHECK_FOR_STACK_OVERFLOW  0//2

#define configUSE_RECURSIVE_MUTEXES     1

#define configUSE_MALLOC_FAILED_HOOK    0//1

#define configUSE_APPLICATION_TASK_TAG  0

#define configUSE_COUNTING_SEMAPHORES   1

#define configGENERATE_RUN_TIME_STATS   0

/* Co-routine definitions. */

#define configUSE_CO_ROUTINES       0

#define configMAX_CO_ROUTINE_PRIORITIES ( 2 )

/* Software timer definitions. */

#define configUSE_TIMERS                1

#define configTIMER_TASK_PRIORITY       ( 2 )

#define configTIMER_QUEUE_LENGTH        10

#define configTIMER_TASK_STACK_DEPTH    ( configMINIMAL_STACK_SIZE * 2 )

/* Set the following definitions to 1 to include the API function, or zero

to exclude the API function. */

#define INCLUDE_vTaskPrioritySet        1

#define INCLUDE_uxTaskPriorityGet       1

#define INCLUDE_vTaskDelete             1

#define INCLUDE_vTaskCleanUpResources   1

#define INCLUDE_vTaskSuspend            1

#define INCLUDE_vTaskDelayUntil         1

#define INCLUDE_vTaskDelay              1

/* Cortex-M specific definitions. */

#ifdef __NVIC_PRIO_BITS

    /* __BVIC_PRIO_BITS will be specified when CMSIS is being used. */

    #define configPRIO_BITS             __NVIC_PRIO_BITS

#else

    #define configPRIO_BITS             4        /* 15 priority levels */

#endif

/* The lowest interrupt priority that can be used in a call to a "set priority"

function. */

#define configLIBRARY_LOWEST_INTERRUPT_PRIORITY         0xf

/* The highest interrupt priority that can be used by any interrupt service

routine that makes calls to interrupt safe FreeRTOS API functions.  DO NOT CALL

INTERRUPT SAFE FREERTOS API FUNCTIONS FROM ANY INTERRUPT THAT HAS A HIGHER

PRIORITY THAN THIS! (higher priorities are lower numeric values. */

#define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY    5

/* Interrupt priorities used by the kernel port layer itself.  These are generic

to all Cortex-M ports, and do not rely on any particular library functions. */

#define configKERNEL_INTERRUPT_PRIORITY         ( configLIBRARY_LOWEST_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )

/* !!!! configMAX_SYSCALL_INTERRUPT_PRIORITY must not be set to zero !!!!

See http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html. */

#define configMAX_SYSCALL_INTERRUPT_PRIORITY    ( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )

/* Normal assert() semantics without relying on the provision of an assert.h

header file. */

//#define configASSERT( x ) if( ( x ) == 0 ) { taskDISABLE_INTERRUPTS(); for( ;; ); }

/* Definitions that map the FreeRTOS port interrupt handlers to their CMSIS

standard names. */

#define vPortSVCHandler SVC_Handler

#define xPortPendSVHandler PendSV_Handler

#define xPortSysTickHandler SysTick_Handler

#endif /* FREERTOS_CONFIG_H */

struct netbuf

{

    struct pbuf *p, *ptr;

    ip_addr_t addr;

    u16_t port;

};

struct netconn

{

    enum netconn_type type; // 连接类型，TCP UDP 或者 RAW

    enum netconn_state state; // 当前连接状态

    union { // 内核中与连接相关的控制块指针

        struct ip_pcb *ip; // IP 控制块

        struct tcp_pcb *tcp; // TCP 控制块

        struct udp_pcb *udp; // UDP 控制块

        struct raw_pcb *raw; // RAW 控制块

    } pcb;

    err_t last_err; // 此连接上最新的错误

    sys_sem_t op_completed; // 用于两部分 API 同步的信号量

    sys_mbox_t recvmbox; // 接收数据的邮箱

    #if LWIP_TCP

    sys_mbox_t acceptmbox; // 用于 TCP 服务器端，连接请求的缓冲队列

    #endif

    #if LWIP_SOCKET

    int socket; // socket 描述符，用于 socket API

    #endif

    #if LWIP_SO_SNDTIMEO

    s32_t send_timeout; // 发送数据时的超时时间

    #endif

    #if LWIP_SO_RCVTIMEO

    int recv_timeout; // 接收数据时的超时时间

    #endif

    #if LWIP_SO_RCVBUF

    int recv_bufsize; // 接收消息队列长度

    s16_t recv_avail; // 数据邮箱 recvmbox 中已缓存的数据长度

    #endif

    u8_t flags; // 标识符

    #if LWIP_TCP

    // 当调用 netconn_write 发送数据但缓存不足的时候，数据会暂时存放在 current_msg 中,等待下一次数据发送，write_offset 记录下一次发送时的索引

    size_t write_offset;

    struct api_msg_msg *current_msg;

    #endif

    netconn_callback callback; // 连接相关回调函数，实现 socket API 时使用

};

//枚举类型，用于描述连接类型

enum netconn_type {

    NETCONN_INVALID = 0, //无效类型

    NETCONN_TCP = 0x10, //TCP

    NETCONN_UDP = 0x20, //UDP

    NETCONN_UDPLITE = 0x21, //UDPLite

    NETCONN_UDPNOCHKSUM= 0x22, //无校验 UDP

    NETCONN_RAW = 0x40 //原始链接

};

//枚举类型，用于描述连接状态，主要用于 TCP 连接中

enum netconn_state

{

    NETCONN_NONE, //不处于任何状态

    NETCONN_WRITE, //正在发送数据

    NETCONN_LISTEN, //侦听状态

    NETCONN_CONNECT, //连接状态

    NETCONN_CLOSE //关闭状态

};

err_t netconn_getaddr(struct netconn *conn, ip_addr_t *addr,u16_t *port, u8_t local);

err_t netconn_bind(struct netconn *conn, ip_addr_t *addr, u16_t port);

err_t netconn_connect(struct netconn *conn, ip_addr_t *addr, u16_t port);

err_t netconn_disconnect (struct netconn *conn);

err_t netconn_accept(struct netconn *conn, struct netconn **new_conn);

err_t netconn_recv(struct netconn *conn, struct netbuf **new_buf);

err_t netconn_send(struct netconn *conn, struct netbuf *buf);

err_t netconn_close(struct netconn *conn);

// TCP/IP 线程名称

#define TCPIP_THREAD_NAME              "TCP/IP"

// TCP/IP 线程栈大小

#define TCPIP_THREAD_STACKSIZE          1000

// TCP/IP 邮箱大小

#define TCPIP_MBOX_SIZE                 5

// 默认 UDP 接收邮箱大小

#define DEFAULT_UDP_RECVMBOX_SIZE       2000

// 默认 TCP 接收邮箱大小

#define DEFAULT_TCP_RECVMBOX_SIZE       2000

// 默认接受邮箱大小

#define DEFAULT_ACCEPTMBOX_SIZE         2000

// 默认线程栈大小

#define DEFAULT_THREAD_STACKSIZE        500

// TCP/IP 线程优先级

#define TCPIP_THREAD_PRIO               (8 - 2)

// LWIP 兼容互斥量

#define LWIP_COMPAT_MUTEX 1

// 允许 LWIP 兼容互斥量

#define LWIP_COMPAT_MUTEX_ALLOWED 0

// LWIP TCP/IP 核心锁定

#define LWIP_TCPIP_CORE_LOCKING 0

#include "FreeRTOS.h"

#include "lwip/opt.h"

#include "task.h"

#if LWIP_NETCONN

#include "lwip/api.h"

#include "lwip/sys.h"

#define UDPECHO_THREAD_PRIO  ( tskIDLE_PRIORITY + 5 )

static struct netconn *conn;

static struct netbuf *buf;

static struct ip4_addr *addr;

static unsigned short port;

/*-----------------------------------------------------------------------------------*/

static void udpecho_thread(void *arg)

{

    err_t err, recv_err;

    LWIP_UNUSED_ARG(arg);

    conn = netconn_new(NETCONN_UDP);

    if (conn!= NULL)

    {

        err = netconn_bind(conn, IP_ADDR_ANY, 6000);

        if (err == ERR_OK)

        {

            while (1)

            {

                recv_err = netconn_recv(conn, &buf);

                if (recv_err == ERR_OK)

                {

                    addr = netbuf_fromaddr(buf);

                    port = netbuf_fromport(buf);

                    netconn_connect(conn, addr, port);

                    buf->addr.addr = 0;

                    netconn_send(conn,buf);

                    netbuf_delete(buf);

                }

            }

        }

        else

        {

            netconn_delete(conn);

            printf("can not bind netconn");

        }

    }

    else

    {

        printf("can create new UDP netconn");

    }

}

/*-----------------------------------------------------------------------------------*/

void udpecho_init(void)

{

    sys_thread_new("udpecho_thread", udpecho_thread, NULL, DEFAULT_THREAD_STACKSIZE,UDPECHO_THREAD_PRIO );

}

#endif /* LWIP_NETCONN */

int main(void)

{

    /* Init task */

    xTaskCreate(Main_task, (const char *)"Main", configMINIMAL_STACK_SIZE * 2, NULL,MAIN_TASK_PRIO, NULL);

    /* Start scheduler */

    vTaskStartScheduler();

    while(1);

}

void Main_task(void * pvParameters)

{

    char LCDDisplayBuf[100] = {0};

    struct ip4_addr DestIPaddr;

    uint8_t flag = 0;

    /* User config the different system Clock */

//    UserRCMClockConfig();

//    /* Configure SysTick */

//    ConfigSysTick();

    USART_Init();

    /* Configures LED2 and LED3 */

    APM_BOARD_LEDInit(LED2);

    APM_BOARD_LEDInit(LED3);

    /* KEY init*/

    APM_BOARD_PBInit(BUTTON_KEY1, BUTTON_MODE_GPIO);

    APM_BOARD_PBInit(BUTTON_KEY2, BUTTON_MODE_GPIO);

    printf("This is a UDP NETCONN Demo! \r\n");

    /* Configure ethernet (GPIOs, clocks, MAC, DMA) */

    ConfigEthernet();

    /* Initilaize the LwIP stack */

    LwIP_Init();

#ifndef USE_DHCP

    /* Use Com printf static IP address*/

    sprintf(LCDDisplayBuf,"TINY board Static IP address \r\n");

    printf("%s",LCDDisplayBuf);

    sprintf(LCDDisplayBuf,"IP: %d.%d.%d.%d \r\n",

    IP_ADDR0,

    IP_ADDR1,

    IP_ADDR2,

    IP_ADDR3);

    printf("%s",LCDDisplayBuf);

    sprintf(LCDDisplayBuf,"NETMASK: %d.%d.%d.%d \r\n",

    NETMASK_ADDR0,

    NETMASK_ADDR1,

    NETMASK_ADDR2,

    NETMASK_ADDR3);

    printf("%s",LCDDisplayBuf);

    sprintf(LCDDisplayBuf,"Gateway: %d.%d.%d.%d \r\n",

    GW_ADDR0,

    GW_ADDR1,

    GW_ADDR2,

    GW_ADDR3);

    printf("%s",LCDDisplayBuf);

    printf("Connect port: %d", COMP_PORT);

#endif

    udpecho_init();

    while(1)

    {

        /* check if any packet received */

        if (ETH_CheckReceivedFrame())

        {

            /* process received ethernet packet */

            LwIP_Pkt_Handle();

        }

        /* handle periodic timers for LwIP */

        LwIP_Periodic_Handle(ETHTimer);

    }

}