Essential for IoT experts: Network protocol stack LwIP (I)

need:

In IoT devices, the TCP/IP network protocol stack is a very important software component. Without the TCP/IP network protocol stack, IoT devices cannot connect to the Internet. The TCP/IP network protocol itself is relatively complex. The amount of TCP/IP implementation code before the emergence of IoT was very large. However, for IoT devices, the memory is very limited and the processor performance is also very limited. This requires a lightweight TCP/IP network protocol stack to run, using very small memory, discarding some unnecessary functions, and retaining the main functions. Due to these requirements, several embedded TCP/IP protocol stacks have been generated, the most common ones are as follows: μC/TCP-IP, LwIP, UIP.

[[267982]]

Common embedded TCP/IP protocol stack

1. μC/TCP-IP:

μC/TCP-IP is a component of Micrium's own operating system UC/OS, which supports both IPv4 and IPv6, supports BSD socket API, and has the most popular socket options. This protocol stack is a compact, reliable, high-performance TCP/IP protocol stack optimized for embedded systems. μC/TCP-IP is completely self-coded with high quality, scalability and reliability, and can quickly configure the required network options to minimize time to market. MicriumμC/TCP-IP embedded protocol stack allows memory footprint to be adjusted according to design requirements. μC/TCP-IP can be configured to include only those network components required by the system. When a component is not used, it can be excluded from the protocol stack, saving valuable memory space.

2. LwIp network protocol stack:

LwIP is a small set of TCP/IP protocol components developed by Adam Dunkels of the Swedish Academy of Sciences. The main goal of achieving this is to reduce resource usage while still having comprehensive TCP functionality. This makes lwIP suitable for embedded systems with 10Kb bytes of free RAM and can accommodate about 40Kb of code ROM. Since its inception, LwIP has been ported to multiple embedded operating systems, including the popular FreeRTOS, Alibaba Cloud's IoT operating system AliOS Things, Huawei's IoT operating system LiteOS, and so on.

3. uIP network protocol stack:

uIP is mainly used for small embedded network protocol stacks for 8-bit and 16-bit microcontrollers. Initially, the uIP network protocol stack was developed by Adam Dunkels of the Swedish Institute of Computer Science. Its source code is written in C language and is completely open source. The biggest advantage of the uIP protocol stack is that it is short and powerful, with small Flash and RAM requirements. It removes uncommon functions in the complete TCP/IP and simplifies the communication process, but retains the protocols that must be used for network communication, focusing on the network layer and transport layer protocols such as IP/TCP/ICMP/UDP/ARP, ensuring the versatility of its code and the stability of its structure.

LwIP protocol stack functions

• IP protocol (Internet Protocol, supports IPv4 and IPv6), and supports packet forwarding on multiple network interfaces.
• Supports ICMP (Internet Control Message Protocol) for network maintenance and debugging.
• Supports IGMP (Internet Group Management Protocol) for multicast traffic management.
• Supports MLD (Multicast Listener Discovery for IPv6). Refers to RFC 2710 standard, but does not support MLDv2.
• Supports Neighbor Discovery Protocol (ND) and stateless address autoconfiguration of IPv6. Reference standards RFC4861 (Neighbor Discovery) and RFC 4862 (Address Autoconfiguration).
• Supports DHCP, AutoIP/APIPA (Zeroconf) and (stateless) DHCPv6.
• Supports UDP (User Datagram Protocol), including the latest UDP-lite extension protocol (error-insensitive UDP)
• Supports TCP protocols including congestion control, RTT estimation, fast recovery and fast forwarding.
• Provides a higher-performance original API. This interface is used when users need higher performance.
• Optional Berkeley-socket API, the most common network programming interface.
• Supports TLS.
• PPPoS and PPPoE (Point-to-Point Protocol over Serial/Ethernet).
• Supports DNS (Domain Name Resolver), including mDNS (multicast DNS).
• 6LoWPAN, based on IEEE 802.15.4 over IPv6, the physical layer is Bluetooth Low Energy (BLE) or ZigBee.

From this point of view, LwIP supports a lot of functions. In addition to the traditional TCPIP, it also supports many of the latest protocols (such as mDNS, UDP-lite, 6LoWPAN, etc.)

Overall architecture

LwIP Architecture

As can be seen from the above figure, IwIP is divided into four layers according to the TCP/IP layering, namely link layer, network layer, transport layer and application layer.

The data processing flow of the protocol stack mainly includes the following three types:

• Each layer is an independent process. The link layer is a process, the IP layer is also a process, and the transport layer is a process. The advantage of this design is that each layer is very clear, the code is easy to understand, and debugging is also convenient. However, the disadvantage of this processing method is that when data is transferred between layers, context switching and memory copying are required. For the operating system, switching between processes and memory copying are time-consuming. When a large number of messages are transmitted, frequent switching and memory copying will occur, resulting in low forwarding efficiency.
• The TCP IP protocol stack is in the kernel of the operating system. Applications communicate with the protocol stack through system calls. This method must implement system calls for various functions and is relatively complex.
• All TCP/IP protocol processing is done in one process. There is no obvious boundary between each layer. Each layer can access the shared memory space. Because each layer can access the shared memory, the performance loss caused by memory copying between each layer is avoided. The lwIP protocol is implemented in this way to improve transmission speed and resource utilization.

The sending and receiving of data packets requires the support of mailboxes and semaphores. If it is based on an operating system, these mechanisms can be provided by the operating system. Porting only requires encapsulating the functions based on mailboxes and signals. If it is a bare-metal porting without an operating system, it is necessary to use interrupts or polling to implement the sending and receiving of data. The workload is relatively greater than without an operating system.

Source code architecture

LwIP protocol stack main directory

We take the latest version 2.1 as an example. LwIP has three main folders: doc, src and test.

Doc is the stored help document. It is different from the text file of the previous 1.4 version of the help document. It uses the doxygen tool to generate HTML format help documents based on the comments of the source code. src is the main source code directory of LwIP, and the test directory is the test scripts and some test protocol stack programs.

The src directory of the LwIP protocol stack

The src directory is the source code directory of the protocol stack, including four folders: api, core, include, and netif. Core is the core of the protocol stack, include is the header file directory, netif provides the driver code of the network interface layer, and the api directory provides the API interfaces of socket, tcp, and memory management. (To be continued)