前面我们基于无OS环境移植了LWIP,这一篇我们来基于RTOS移植LWIP,与无OS环境基本一致,只是需要实现一些系统组件的接口,信号量互斥量等。
我们参考lwip\contrib\ports\freertos下的移植进行修改,如果使用的是freertos的话直接参考即可。如果用的其他RTOS可以复制一份修改。
复制lwip\contrib\ports\freertos并添加cc.h和lwipopts.h(这两个文件可以从contrib下其他样例代码中复制)
还是和无OS一样实现随机数函数
x, __LINE__, __FILE__);} while(0)extern uint32_t lwip_port_rand(void);
如果使用的freertos直接使用即可，否则按需修改。
相关接口。
/** Copyright (c) 2017 Simon Goldschmidt* All rights reserved.** Redistribution and use in source and binary forms, with or without modification,* are permitted provided that the following conditions are met:** 1. Redistributions of source code must retain the above copyright notice,* this list of conditions and the following disclaimer.* 2. Redistributions in binary form must reproduce the above copyright notice,* this list of conditions and the following disclaimer in the documentation* and/or other materials provided with the distribution.* 3. The name of the author may not be used to endorse or promote products* derived from this software without specific prior written permission.** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY* OF SUCH DAMAGE.** This file is part of the lwIP TCP/IP stack.** Author: Simon Goldschmdit**//** This is returned by _fromisr() sys functions to tell the outermost function* that a higher priority task was woken and the scheduler needs to be invoked.*//* This port includes FreeRTOS headers in sys_arch.c only.* FreeRTOS uses pointers as object types. We use wrapper structs instead of* void pointers directly to get a tiny bit of type safety.*/void sys_arch_msleep(u32_t delay_ms);typedef u32_t sys_prot_t;struct _sys_mut {void *mut;};typedef struct _sys_mut sys_mutex_t;struct _sys_sem {void *sem;};typedef struct _sys_sem sys_sem_t;struct _sys_mbox {void *mbx;};typedef struct _sys_mbox sys_mbox_t;struct _sys_thread {void *thread_handle;};typedef struct _sys_thread sys_thread_t;sys_sem_t* sys_arch_netconn_sem_get(void);void sys_arch_netconn_sem_alloc(void);void sys_arch_netconn_sem_free(void);
/** Copyright (c) 2017 Simon Goldschmidt* All rights reserved.** Redistribution and use in source and binary forms, with or without modification,* are permitted provided that the following conditions are met:** 1. Redistributions of source code must retain the above copyright notice,* this list of conditions and the following disclaimer.* 2. Redistributions in binary form must reproduce the above copyright notice,* this list of conditions and the following disclaimer in the documentation* and/or other materials provided with the distribution.* 3. The name of the author may not be used to endorse or promote products* derived from this software without specific prior written permission.** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY* OF SUCH DAMAGE.** This file is part of the lwIP TCP/IP stack.** Author: Simon Goldschmidt**//* lwIP includes. *//** Set this to 1 if you want the stack size passed to sys_thread_new() to be* interpreted as number of stack words (FreeRTOS-like).* Default is that they are interpreted as byte count (lwIP-like).*//** Set this to 1 to use a mutex for SYS_ARCH_PROTECT() critical regions.* Default is 0 and locks interrupts/scheduler for SYS_ARCH_PROTECT().*//** Set this to 1 to include a sanity check that SYS_ARCH_PROTECT() and* SYS_ARCH_UNPROTECT() are called matching.*//** Set this to 1 to let sys_mbox_free check that queues are empty when freed *//** Set this to 1 to enable core locking check functions in this port.* For this to work, you'll have to define LWIP_ASSERT_CORE_LOCKED()* and LWIP_MARK_TCPIP_THREAD() correctly in your lwipopts.h! *//** Set this to 0 to implement sys_now() yourself, e.g. using a hw timer.* Default is 1, where FreeRTOS ticks are used to calculate back to ms.*/static SemaphoreHandle_t sys_arch_protect_mutex;static sys_prot_t sys_arch_protect_nesting;/* Initialize this module (see description in sys.h) */voidsys_init(void){/* initialize sys_arch_protect global mutex */sys_arch_protect_mutex = xSemaphoreCreateRecursiveMutex();LWIP_ASSERT("failed to create sys_arch_protect mutex",sys_arch_protect_mutex != NULL);}u32_tsys_now(void){return xTaskGetTickCount() * portTICK_PERIOD_MS;}u32_tsys_jiffies(void){return xTaskGetTickCount();}sys_prot_tsys_arch_protect(void){BaseType_t ret;LWIP_ASSERT("sys_arch_protect_mutex != NULL", sys_arch_protect_mutex != NULL);ret = xSemaphoreTakeRecursive(sys_arch_protect_mutex, portMAX_DELAY);LWIP_ASSERT("sys_arch_protect failed to take the mutex", ret == pdTRUE);taskENTER_CRITICAL();{/* every nested call to sys_arch_protect() returns an increased number */sys_prot_t ret = sys_arch_protect_nesting;sys_arch_protect_nesting++;LWIP_ASSERT("sys_arch_protect overflow", sys_arch_protect_nesting > ret);return ret;}return 1;}voidsys_arch_unprotect(sys_prot_t pval){BaseType_t ret;LWIP_ASSERT("unexpected sys_arch_protect_nesting", sys_arch_protect_nesting > 0);sys_arch_protect_nesting--;LWIP_ASSERT("unexpected sys_arch_protect_nesting", sys_arch_protect_nesting == pval);LWIP_ASSERT("sys_arch_protect_mutex != NULL", sys_arch_protect_mutex != NULL);ret = xSemaphoreGiveRecursive(sys_arch_protect_mutex);LWIP_ASSERT("sys_arch_unprotect failed to give the mutex", ret == pdTRUE);taskEXIT_CRITICAL();LWIP_UNUSED_ARG(pval);}voidsys_arch_msleep(u32_t delay_ms){TickType_t delay_ticks = delay_ms / portTICK_RATE_MS;vTaskDelay(delay_ticks);}/* Create a new mutex*/err_tsys_mutex_new(sys_mutex_t *mutex){LWIP_ASSERT("mutex != NULL", mutex != NULL);mutex->mut = xSemaphoreCreateRecursiveMutex();if(mutex->mut == NULL) {SYS_STATS_INC(mutex.err);return ERR_MEM;}SYS_STATS_INC_USED(mutex);return ERR_OK;}voidsys_mutex_lock(sys_mutex_t *mutex){BaseType_t ret;LWIP_ASSERT("mutex != NULL", mutex != NULL);LWIP_ASSERT("mutex->mut != NULL", mutex->mut != NULL);ret = xSemaphoreTakeRecursive(mutex->mut, portMAX_DELAY);LWIP_ASSERT("failed to take the mutex", ret == pdTRUE);}voidsys_mutex_unlock(sys_mutex_t *mutex){BaseType_t ret;LWIP_ASSERT("mutex != NULL", mutex != NULL);LWIP_ASSERT("mutex->mut != NULL", mutex->mut != NULL);ret = xSemaphoreGiveRecursive(mutex->mut);LWIP_ASSERT("failed to give the mutex", ret == pdTRUE);}voidsys_mutex_free(sys_mutex_t *mutex){LWIP_ASSERT("mutex != NULL", mutex != NULL);LWIP_ASSERT("mutex->mut != NULL", mutex->mut != NULL);SYS_STATS_DEC(mutex.used);vSemaphoreDelete(mutex->mut);mutex->mut = NULL;}err_tsys_sem_new(sys_sem_t *sem, u8_t initial_count){LWIP_ASSERT("sem != NULL", sem != NULL);LWIP_ASSERT("initial_count invalid (not 0 or 1)",(initial_count == 0) || (initial_count == 1));sem->sem = xSemaphoreCreateBinary();if(sem->sem == NULL) {SYS_STATS_INC(sem.err);return ERR_MEM;}SYS_STATS_INC_USED(sem);if(initial_count == 1) {BaseType_t ret = xSemaphoreGive(sem->sem);LWIP_ASSERT("sys_sem_new: initial give failed", ret == pdTRUE);}return ERR_OK;}voidsys_sem_signal(sys_sem_t *sem){BaseType_t ret;LWIP_ASSERT("sem != NULL", sem != NULL);LWIP_ASSERT("sem->sem != NULL", sem->sem != NULL);ret = xSemaphoreGive(sem->sem);/* queue full is OK, this is a signal only... */LWIP_ASSERT("sys_sem_signal: sane return value",(ret == pdTRUE) || (ret == errQUEUE_FULL));}u32_tsys_arch_sem_wait(sys_sem_t *sem, u32_t timeout_ms){BaseType_t ret;LWIP_ASSERT("sem != NULL", sem != NULL);LWIP_ASSERT("sem->sem != NULL", sem->sem != NULL);if(!timeout_ms) {/* wait infinite */ret = xSemaphoreTake(sem->sem, portMAX_DELAY);LWIP_ASSERT("taking semaphore failed", ret == pdTRUE);} else {TickType_t timeout_ticks = timeout_ms / portTICK_RATE_MS;ret = xSemaphoreTake(sem->sem, timeout_ticks);if (ret == errQUEUE_EMPTY) {/* timed out */return SYS_ARCH_TIMEOUT;}LWIP_ASSERT("taking semaphore failed", ret == pdTRUE);}/* Old versions of lwIP required us to return the time waited.This is not the case any more. Just returning != SYS_ARCH_TIMEOUThere is enough. */return 1;}voidsys_sem_free(sys_sem_t *sem){LWIP_ASSERT("sem != NULL", sem != NULL);LWIP_ASSERT("sem->sem != NULL", sem->sem != NULL);SYS_STATS_DEC(sem.used);vSemaphoreDelete(sem->sem);sem->sem = NULL;}err_tsys_mbox_new(sys_mbox_t *mbox, int size){LWIP_ASSERT("mbox != NULL", mbox != NULL);LWIP_ASSERT("size > 0", size > 0);mbox->mbx = xQueueCreate((UBaseType_t)size, sizeof(void *));if(mbox->mbx == NULL) {SYS_STATS_INC(mbox.err);return ERR_MEM;}SYS_STATS_INC_USED(mbox);return ERR_OK;}voidsys_mbox_post(sys_mbox_t *mbox, void *msg){BaseType_t ret;LWIP_ASSERT("mbox != NULL", mbox != NULL);LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);ret = xQueueSendToBack(mbox->mbx, &msg, portMAX_DELAY);LWIP_ASSERT("mbox post failed", ret == pdTRUE);}err_tsys_mbox_trypost(sys_mbox_t *mbox, void *msg){BaseType_t ret;LWIP_ASSERT("mbox != NULL", mbox != NULL);LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);ret = xQueueSendToBack(mbox->mbx, &msg, 0);if (ret == pdTRUE) {return ERR_OK;} else {LWIP_ASSERT("mbox trypost failed", ret == errQUEUE_FULL);SYS_STATS_INC(mbox.err);return ERR_MEM;}}err_tsys_mbox_trypost_fromisr(sys_mbox_t *mbox, void *msg){BaseType_t ret;BaseType_t xHigherPriorityTaskWoken = pdFALSE;LWIP_ASSERT("mbox != NULL", mbox != NULL);LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);ret = xQueueSendToBackFromISR(mbox->mbx, &msg, &xHigherPriorityTaskWoken);if (ret == pdTRUE) {if (xHigherPriorityTaskWoken == pdTRUE) {return ERR_NEED_SCHED;}return ERR_OK;} else {LWIP_ASSERT("mbox trypost failed", ret == errQUEUE_FULL);SYS_STATS_INC(mbox.err);return ERR_MEM;}}u32_tsys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout_ms){BaseType_t ret;void *msg_dummy;LWIP_ASSERT("mbox != NULL", mbox != NULL);LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);if (!msg) {msg = &msg_dummy;}if (!timeout_ms) {/* wait infinite */ret = xQueueReceive(mbox->mbx, &(*msg), portMAX_DELAY);LWIP_ASSERT("mbox fetch failed", ret == pdTRUE);} else {TickType_t timeout_ticks = timeout_ms / portTICK_RATE_MS;ret = xQueueReceive(mbox->mbx, &(*msg), timeout_ticks);if (ret == errQUEUE_EMPTY) {/* timed out */*msg = NULL;return SYS_ARCH_TIMEOUT;}LWIP_ASSERT("mbox fetch failed", ret == pdTRUE);}/* Old versions of lwIP required us to return the time waited.This is not the case any more. Just returning != SYS_ARCH_TIMEOUThere is enough. */return 1;}u32_tsys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg){BaseType_t ret;void *msg_dummy;LWIP_ASSERT("mbox != NULL", mbox != NULL);LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);if (!msg) {msg = &msg_dummy;}ret = xQueueReceive(mbox->mbx, &(*msg), 0);if (ret == errQUEUE_EMPTY) {*msg = NULL;return SYS_MBOX_EMPTY;}LWIP_ASSERT("mbox fetch failed", ret == pdTRUE);return 0;}voidsys_mbox_free(sys_mbox_t *mbox){LWIP_ASSERT("mbox != NULL", mbox != NULL);LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);{UBaseType_t msgs_waiting = uxQueueMessagesWaiting(mbox->mbx);LWIP_ASSERT("mbox quence not empty", msgs_waiting == 0);if (msgs_waiting != 0) {SYS_STATS_INC(mbox.err);}}vQueueDelete(mbox->mbx);SYS_STATS_DEC(mbox.used);}sys_thread_tsys_thread_new(const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio){TaskHandle_t rtos_task;BaseType_t ret;sys_thread_t lwip_thread;size_t rtos_stacksize;LWIP_ASSERT("invalid stacksize", stacksize > 0);rtos_stacksize = (size_t)stacksize;rtos_stacksize = (size_t)stacksize / sizeof(StackType_t);/* lwIP's lwip_thread_fn matches FreeRTOS' TaskFunction_t, so we can pass thethread function without adaption here. */ret = xTaskCreate(thread, name, (configSTACK_DEPTH_TYPE)rtos_stacksize, arg, prio, &rtos_task);LWIP_ASSERT("task creation failed", ret == pdTRUE);lwip_thread.thread_handle = rtos_task;return lwip_thread;}sys_sem_t *sys_arch_netconn_sem_get(void){void* ret;TaskHandle_t task = xTaskGetCurrentTaskHandle();LWIP_ASSERT("task != NULL", task != NULL);ret = pvTaskGetThreadLocalStoragePointer(task, 0);return ret;}voidsys_arch_netconn_sem_alloc(void){void *ret;TaskHandle_t task = xTaskGetCurrentTaskHandle();LWIP_ASSERT("task != NULL", task != NULL);ret = pvTaskGetThreadLocalStoragePointer(task, 0);if(ret == NULL) {sys_sem_t *sem;err_t err;/* need to allocate the memory for this semaphore */sem = mem_malloc(sizeof(sys_sem_t));LWIP_ASSERT("sem != NULL", sem != NULL);err = sys_sem_new(sem, 0);LWIP_ASSERT("err == ERR_OK", err == ERR_OK);LWIP_ASSERT("sem invalid", sys_sem_valid(sem));vTaskSetThreadLocalStoragePointer(task, 0, sem);}}void sys_arch_netconn_sem_free(void){void* ret;TaskHandle_t task = xTaskGetCurrentTaskHandle();LWIP_ASSERT("task != NULL", task != NULL);ret = pvTaskGetThreadLocalStoragePointer(task, 0);if(ret != NULL) {sys_sem_t *sem = ret;sys_sem_free(sem);mem_free(sem);vTaskSetThreadLocalStoragePointer(task, 0, NULL);}}/** Flag the core lock held. A counter for recursive locks. */static u8_t lwip_core_lock_count;static TaskHandle_t lwip_core_lock_holder_thread;voidsys_lock_tcpip_core(void){sys_mutex_lock(&lock_tcpip_core);if (lwip_core_lock_count == 0) {lwip_core_lock_holder_thread = xTaskGetCurrentTaskHandle();}lwip_core_lock_count++;}voidsys_unlock_tcpip_core(void){lwip_core_lock_count--;if (lwip_core_lock_count == 0) {lwip_core_lock_holder_thread = 0;}sys_mutex_unlock(&lock_tcpip_core);}static TaskHandle_t lwip_tcpip_thread;voidsys_mark_tcpip_thread(void){lwip_tcpip_thread = xTaskGetCurrentTaskHandle();}voidsys_check_core_locking(void){/* Embedded systems should check we are NOT in an interrupt context here *//* E.g. core Cortex-M3/M4 ports:configASSERT( ( portNVIC_INT_CTRL_REG & portVECTACTIVE_MASK ) == 0 );Instead, we use more generic FreeRTOS functions here, which should fail from ISR: */taskENTER_CRITICAL();taskEXIT_CRITICAL();if (lwip_tcpip_thread != 0) {TaskHandle_t current_thread = xTaskGetCurrentTaskHandle();LWIP_ASSERT("Function called without core lock",current_thread == lwip_core_lock_holder_thread && lwip_core_lock_count > 0);LWIP_ASSERT("Function called from wrong thread", current_thread == lwip_tcpip_thread);}}
配置
/*** @file** lwIP Options Configuration*//** Copyright (c) 2001-2004 Swedish Institute of Computer Science.* All rights reserved.** Redistribution and use in source and binary forms, with or without modification,* are permitted provided that the following conditions are met:** 1. Redistributions of source code must retain the above copyright notice,* this list of conditions and the following disclaimer.* 2. Redistributions in binary form must reproduce the above copyright notice,* this list of conditions and the following disclaimer in the documentation* and/or other materials provided with the distribution.* 3. The name of the author may not be used to endorse or promote products* derived from this software without specific prior written permission.** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY* OF SUCH DAMAGE.** This file is part of the lwIP TCP/IP stack.** Author: Adam Dunkels**//** Include user defined options first. Anything not defined in these files* will be set to standard values. Override anything you don't like!*//*--------------------------------------------------------- Platform specific locking ---------------------------------------------------------*//*** SYS_LIGHTWEIGHT_PROT==1: if you want inter-task protection for certain* critical regions during buffer allocation, deallocation and memory* allocation and deallocation.*//*** NO_SYS==1: Provides VERY minimal functionality. Otherwise,* use lwIP facilities.*//*---------------------------------------------- Memory options ----------------------------------------------*//*** MEM_ALIGNMENT: should be set to the alignment of the CPU* 4 byte alignment -> #define MEM_ALIGNMENT 4* 2 byte alignment -> #define MEM_ALIGNMENT 2*//*** MEM_SIZE: the size of the heap memory. If the application will send* a lot of data that needs to be copied, this should be set high.*//*---------------------------------------------------------- Internal Memory Pool Sizes ----------------------------------------------------------*//*** MEMP_NUM_PBUF: the number of memp struct pbufs (used for PBUF_ROM and PBUF_REF).* If the application sends a lot of data out of ROM (or other static memory),* this should be set high.*//*** MEMP_NUM_RAW_PCB: Number of raw connection PCBs* (requires the LWIP_RAW option)*//*** MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One* per active UDP "connection".* (requires the LWIP_UDP option)*//*** MEMP_NUM_TCP_PCB: the number of simulatenously active TCP connections.* (requires the LWIP_TCP option)*//*** MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP connections.* (requires the LWIP_TCP option)*//*** MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP segments.* (requires the LWIP_TCP option)*//*** MEMP_NUM_REASSDATA: the number of simultaneously IP packets queued for* reassembly (whole packets, not fragments!)*//*** MEMP_NUM_ARP_QUEUE: the number of simulateously queued outgoing* packets (pbufs) that are waiting for an ARP request (to resolve* their destination address) to finish.* (requires the ARP_QUEUEING option)*//*** MEMP_NUM_SYS_TIMEOUT: the number of simulateously active timeouts.* (requires NO_SYS==0)*//*** MEMP_NUM_NETBUF: the number of struct netbufs.* (only needed if you use the sequential API, like api_lib.c)*//*** MEMP_NUM_NETCONN: the number of struct netconns.* (only needed if you use the sequential API, like api_lib.c)*//*** MEMP_NUM_TCPIP_MSG_API: the number of struct tcpip_msg, which are used* for callback/timeout API communication.* (only needed if you use tcpip.c)*//*** MEMP_NUM_TCPIP_MSG_INPKT: the number of struct tcpip_msg, which are used* for incoming packets.* (only needed if you use tcpip.c)*//*** PBUF_POOL_SIZE: the number of buffers in the pbuf pool.*//*------------------------------------------- ARP options -------------------------------------------*//*** LWIP_ARP==1: Enable ARP functionality.*//*------------------------------------------ IP options ------------------------------------------*//*** IP_FORWARD==1: Enables the ability to forward IP packets across network* interfaces. If you are going to run lwIP on a device with only one network* interface, define this to 0.*//*** IP_OPTIONS: Defines the behavior for IP options.* IP_OPTIONS_ALLOWED==0: All packets with IP options are dropped.* IP_OPTIONS_ALLOWED==1: IP options are allowed (but not parsed).*//*** IP_REASSEMBLY==1: Reassemble incoming fragmented IP packets. Note that* this option does not affect outgoing packet sizes, which can be controlled* via IP_FRAG.*//*** IP_FRAG==1: Fragment outgoing IP packets if their size exceeds MTU. Note* that this option does not affect incoming packet sizes, which can be* controlled via IP_REASSEMBLY.*//*** IP_REASS_MAXAGE: Maximum time (in multiples of IP_TMR_INTERVAL - so seconds, normally)* a fragmented IP packet waits for all fragments to arrive. If not all fragments arrived* in this time, the whole packet is discarded.*//*** IP_REASS_MAX_PBUFS: Total maximum amount of pbufs waiting to be reassembled.* Since the received pbufs are enqueued, be sure to configure* PBUF_POOL_SIZE > IP_REASS_MAX_PBUFS so that the stack is still able to receive* packets even if the maximum amount of fragments is enqueued for reassembly!*//*** IP_FRAG_USES_STATIC_BUF==1: Use a static MTU-sized buffer for IP* fragmentation. Otherwise pbufs are allocated and reference the original* packet data to be fragmented.*//*** IP_DEFAULT_TTL: Default value for Time-To-Live used by transport layers.*//*-------------------------------------------- ICMP options --------------------------------------------*//*** LWIP_ICMP==1: Enable ICMP module inside the IP stack.* Be careful, disable that make your product non-compliant to RFC1122*//*------------------------------------------- RAW options -------------------------------------------*//*** LWIP_RAW==1: Enable application layer to hook into the IP layer itself.*//*-------------------------------------------- DHCP options --------------------------------------------*//*** LWIP_DHCP==1: Enable DHCP module.*//*---------------------------------------------- AUTOIP options ----------------------------------------------*//*** LWIP_AUTOIP==1: Enable AUTOIP module.*//*-------------------------------------------- SNMP options --------------------------------------------*//*** LWIP_SNMP==1: Turn on SNMP module. UDP must be available for SNMP* transport.*//*-------------------------------------------- IGMP options --------------------------------------------*//*** LWIP_IGMP==1: Turn on IGMP module.*//*-------------------------------------------- DNS options ---------------------------------------------*//*** LWIP_DNS==1: Turn on DNS module. UDP must be available for DNS* transport.*//*------------------------------------------- UDP options -------------------------------------------*//*** LWIP_UDP==1: Turn on UDP.*//*------------------------------------------- TCP options -------------------------------------------*//*** LWIP_TCP==1: Turn on TCP.*//*-------------------------------------------- Pbuf options --------------------------------------------*//*** PBUF_LINK_HLEN: the number of bytes that should be allocated for a* link level header. The default is 14, the standard value for* Ethernet.*//*** PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. The default is* designed to accommodate single full size TCP frame in one pbuf, including* TCP_MSS, IP header, and link header.**//*---------------------------------------------- LOOPIF options ----------------------------------------------*//*** LWIP_HAVE_LOOPIF==1: Support loop interface (127.0.0.1) and loopif.c*//*-------------------------------------------------------- Sequential layer options --------------------------------------------------------*//*** LWIP_NETCONN==1: Enable Netconn API (require to use api_lib.c)*//*---------------------------------------------- Socket options ----------------------------------------------*//*** LWIP_SOCKET==1: Enable Socket API (require to use sockets.c)*//*** SO_REUSE==1: Enable SO_REUSEADDR*//*-------------------------------------------------- Statistics options --------------------------------------------------*//*** LWIP_STATS==1: Enable statistics collection in lwip_stats.*//*------------------------------------------- PPP options -------------------------------------------*//*** PPP_SUPPORT==1: Enable PPP.*//*------------------------------------------------- Threading options -------------------------------------------------*/void sys_check_core_locking(void);
struct tms {uint32_t tms_utime; /* user time */uint32_t tms_stime; /* system time */uint32_t tms_cutime; /* user time, children */uint32_t tms_cstime; /* system time, children */};void perf_times(struct tms *t);void perf_print_times(struct tms *start, struct tms *end, char *key);//#define PERF 1struct tms __perf_end; \perf_times(&__perf_start)perf_print_times(&__perf_start, &__perf_end, x);
extern uint32_t sys_now(void);void perf_times(struct tms *t){t->tms_stime = sys_now();}void perf_print_times(struct tms *start, struct tms *end, char *key){printf("%s: %lumS\n", key, end->tms_stime - start->tms_stime);}
struct tms {uint32_t tms_utime; /* user time */uint32_t tms_stime; /* system time */uint32_t tms_cutime; /* user time, children */uint32_t tms_cstime; /* system time, children */};void perf_times(struct tms *t);void perf_print_times(struct tms *start, struct tms *end, char *key);//#define PERF 1struct tms __perf_end; \perf_times(&__perf_start)perf_print_times(&__perf_start, &__perf_end, x);
extern uint32_t sys_now(void);void perf_times(struct tms *t){t->tms_stime = sys_now();}void perf_print_times(struct tms *start, struct tms *end, char *key){printf("%s: %lumS\n", key, end->tms_stime - start->tms_stime);}
Lwipopts.h中
有OS则NO_SYS配置为0
#define NO_SYS 0
此时Sys_arch.h/sys_arch.c需要实现以下接口
sys_init
sys_now 获取ms值
sys_jiffies获取滴答值
sys_arch_msleep
sys_sem_new
sys_sem_signal
sys_arch_sem_wait
sys_sem_free
LWIP_COMPAT_MUTEX为0时实现以下互斥量接口，否则自动使用信号量实现
sys_mutex_new
sys_mutex_lock
sys_mutex_unlock
sys_mutex_free
sys_mbox_new
sys_mbox_post
sys_mbox_trypost
sys_mbox_trypost_fromisr
sys_arch_mbox_fetch
sys_arch_mbox_tryfetch
sys_mbox_free
需要设置消息邮箱的大小
sys_thread_new
配置默认线程栈大小和优先级
如果使能LWIP_NETCONN_SEM_PER_THREAD
sys_arch_netconn_sem_get
sys_arch_netconn_sem_alloc
sys_arch_netconn_sem_free
如果使能LWIP_FREERTOS_CHECK_CORE_LOCKING和
LWIP_TCPIP_CORE_LOCKING
sys_lock_tcpip_core
sys_unlock_tcpip_core
sys_mark_tcpip_thread
sys_check_core_locking
SYS_LIGHTWEIGHT_PROT使能时
sys_arch_protect
sys_arch_unprotect
Lwipopts.h中
#define LWIP_PROVIDE_ERRNO 1
则使用LWIP自己实现的errno.h相关错误码和接口。
如果有互斥量则
Lwipopts.h中
#define LWIP_COMPAT_MUTEX 0
如果定义为1则使用信号量替代互斥量
Sys.h中
Sys_arch.c中
#define LWIP_FREERTOS_CHECK_CORE_LOCKING 1
Lwipopts.h中
#define LWIP_TCPIP_CORE_LOCKING 1
有OS了我们可以直接使用OS提供的堆管理，LWIP的堆和内存池参见前两篇文章分析。
Lwipopts.h中
配置内存池memp.c使用堆实现mem_malloc,mem_free
#define MEMP_MEM_MALLOC 1
配置使用系统的堆管理
#define MEM_LIBC_MALLOC 1
此时MEM_USE_POOLS必须为0
实现以下几个接口
mem_clib_free
mem_clib_malloc
mem_clib_calloc
另外就是配置使用内存池的各个组建的内存池大小
MEMP_NUM_xxx
在系统接口中实现
sys_now
sys_jiffies
不定义LWIP_ASSERT
debug.h中
LWIP_PLATFORM_ASSERT(message); }} while(0)
未定义LWIP_PLATFORM_ASSERT则
x, __LINE__, __FILE__); fflush(NULL); abort();} while(0)
如果有printf可以cc.h中定义为
#define LWIP_PLATFORM_ASSERT(x) do {printf("Assertion \"%s\" failed at line %d in %s\n", \x, __LINE__, __FILE__);} while(0)
使能配置LWIP_DEBUG
实现LWIP_PLATFORM_DIAG行
arch.h中默认是
LWIP_DBG_ON
LWIP_DBG_TYPES_ON
LWIP_DBG_MASK_LEVEL
复制\contrib\apps\tcpecho下的tcpeco.c/h到自己工程中
调用
tcpecho_init
初始化
关键初始化过程
tcpip_init(0,0);
netif_add(&netif, (const ip_addr_t *)&ipaddr, (const ip_addr_t *)&netmask, (const ip_addr_t *)&gw, NULL, &lwip_port_eth_init, ðernet_input);
netif_set_default(&netif);
if (netif_is_link_up(&netif))
{
netif_set_up(&netif);
}
else
{
netif_set_down(&netif);
}
tcpecho_init(); //port 7
PC作为客户端
添加以下代码到自己的工程
src\apps\lwiperf\lwiperf.c
src\include\lwip\apps\lwiperf.h
contrib\examples\lwiperf\lwiperf_example.c/h
端口为lwiperf.h中定义
#define LWIPERF_TCP_PORT_DEFAULT 5001
调用
lwiperf_example_init();
初始化
使用Jperf
PC为client模式
