ARM硬件平台上基于UCOS移植Lwip网络协议栈

只看该作者 · 2019-3-30 17:33

1硬件平台 1
1.1硬件平台简介 1
1.2 硬件设计及电路原理图 2
2. Keil 开发工具及Keil工程简介 6
2.1 Keil开发工具 6
2.2 Keil工程简介 6
2.3 链接文件、启动文件分析 6
3. UCOS移植 11
3.1 ucos简介 11
3.2 ucos移植总述 11
3.3 和移植UCOS有关的ARM芯片知识 11
3.4 系统堆栈和UCOS的任务堆栈 14
3.5 系统时钟 14
3.6 任务级任务切换 14
3.7 中断级任务切换 16
4.Lwip移植 18
4.1 lwip简介 18
4.2 lwip移植总述 18
4.3移植lwip操作系统模拟层 19
4.4 根据lwip提供的软件架构编写相应的网卡芯片驱动 27
4.5 移植完成后测试TCP/IP协议栈 35
4.6 设计并实现简单的WEB服务器 37

只看该作者 · 2019-3-30 17:33

1.硬件平台
1.1硬件平台简介
   为保证网络协议栈的顺利移植，选用了LPC2220作为主控芯片，RTL8019AS作为网卡芯片，使用HR901170A进行电平转换、滤波。

   LPC2220是Philips公司推出的微处理器，片上有64K的RAM空间，通过总线很容易再扩展ROM和RAM。芯片还拥有丰富的IO接口以及多种中断源，还集成了多种定时器、PWM等，另外，该芯片内部集成了很多串行通讯协议，如SPIUART等。

   RTL8019AS是由台湾Realtek公司生产的以太网控制器。他符合EthernetII与IEEE802.3标准，100脚的PQFP封装，采用全双工收发并可同时达到10Mb/s的速率，内置16kB的SRAM，支持8/16位数据总线，8个中断申请线以及16个I/O基地址选择。

   HR901170A是汉仁电子有限公司生产的RJ45接口连接器(带网络变压器／滤波器)，该连接器满足IEEES02．3和IEEE902．3ab标准，能够较好地抑制电磁干扰。通过HR901170A系统就可以连接到以太网上。

基于LPC2220和RTL8019AS的上述特点，我们使用此款芯片可以设计出满足移植Lwip网络协议栈所需要的硬件运行环境。

只看该作者 · 2019-3-30 17:35

1.2 硬件设计及电路原理图

图1.2-1硬件电路连接图1

图1.2-2硬件电路连接图2

   RTL8019AS芯片工作方式分为3种：①跳线方式，网卡的i/o和中断由跳线决定。②即插即用方式，由软件进行自动配置plug and play。③免跳线方式，网卡的i/o和中断由外接的93c46里的内容决定。在嵌入式应用场合，为了节约成本，一般不使用93c46的，可以降低成本，同时又减少连线。我们选择使用跳线模式，使用此模式的硬件设置方式为第65引脚（JP）接高电平，如图1.2-2硬件电路连接图2所示。

   硬件复位引脚33（RSTDRV），此引脚为网卡芯片硬件复位引脚，RSTDRV为高电平有效，至少需要800ns的宽度。由硬件电路图可知，此引脚连接到LPC2220的P0.8上。

   中断引脚（INT7-0）为97-100,1-4 共有8个中断引脚，但使用时只是用一个中断引脚，选择哪个引脚作为中断信号是根据[80-78][IRQS2-0]来决定的，根据电路图可IRQS2-0这三个引脚悬空，RTL8019AS内部有下拉电阻，故IRQS2-0这三个引脚电平都为0，根据手册可知，选择的是INT0作为中断源引脚，此引脚连接到LPC2220的P0.9引脚。

   64脚（AUI），该引脚决定使用aui还是bnc接口。我们用的网卡的接口一般是bnc的，很少用aui。bnc接口方式支持8线双绞或同轴电缆。高电平时使用aui接口，悬空为低电平，使用bnc接口。我们将该引脚悬空即可。

   网络接口类型由74，77（PL0,PL1)引脚决定，我们使用第一种自动检测就可以了。会自动检测接口类型然后进行工作。自动检测是用同轴还是双绞线。这两个引脚内部存在下拉电阻，悬空即可。

   芯片的brom地址由以下引脚72，71，69，68，67（BS4..BS0)决定，在嵌入式领域一般都不用该brom。brom是bootrom的缩写。在电脑里用来做无盘工作站时候用到，可以从网卡进行引导，而不是从a盘，c盘等引导系统。故悬空即可。

RTL8019AS支持3支可编程LED灯，电路连接见原理图。

RTL8019AS与主控芯片间通讯的输入/输出地址共有32个，地址偏移量为00H-1FH。

RTL8019AS的IO基地址在跳线模式下由[85-84,82-81] [IOS3-0]这四个引脚状态决定，电路图中这四个引脚悬空，故这四个引脚状态都为0，根据数据手册可知RTL8019AS的IO基地址为300H，将300H化成二进制数值00110000 0000，很明显地址中第8、9为地址为1，第6、7位和10-19位全部为0。我们仅需要控制第0-4位地址，就可以产生00H-1FH这32个偏移量。电路原理图中SA8、SA9接+5v，SA10-SA19接的是地。

电路图中SA0-SA4分别接的是LPC2220的A1-A5引脚，而SA5接的是NET_nCS引脚。

图1.2-2硬件电路连接图3

NET_nCS的信号是根据nCS3（BANK3的片选信号）和A22地址线信号产生的。

数据总线SD0-SD15连接到LPC2220的D0-D15，组成16bit总线。

产生00H-1FH的偏移量需要NET_nCS信号为低。我们总结一下，我们的RTL8019AS需要的地址是300H-301FH，硬件连线决定了这个地址偏移量。我们将RTL8019AS接到LPC2220的BANK3上。对LPC2220来说，只产生00H-1FH的偏移量就可以。LPC2220的BANK3起始地址是0X83000000，也就是说当访问这个地址时才会产生nCS3为低的信号，如果BANK3只需要连接网卡的话，我们就可以直接利用nCS3信号作为选通网卡芯片的信号即可，但我们硬件设计时将BANK3又分成了几个独立的访问空间用于挂接不同的总线器件。我们利用地址线A21、A22、A23将BANK3分为0X834000000、0x83100000、0x83800000这几个独立空间。我们只分析利用A22地址线信号和nCS3

产生的NET_nCS信号，此信号线硬件上连接到RTL8019AS的SA5上，A22地址线上信号为高电平并且nCS3产生低电平信号，这种情况下NET_nCS才是低电平，而只有NET_nCS为低电平时，才能产生RTL8019AS需要的300H-301FH地址偏移量。现在通过LPC2220访问地址空间0x83400000，这个时候根据上面分析NET_nCS为低电平，也即RTL8019AS的SA5为低电平，第四位地址线SA0-SA4连接的是LPC2220的A1-A5，

访问0x83400000、0x83400001对应的RTL8019AS地址即为300H，同理0x83400010、0x83400011对应的RTL8019AS地址即为301H。我们访问LPC2220的0x83400000-0x8340003F即访问了RTL8019AS的32个偏移量。

只看该作者 · 2019-3-30 17:40

2. Keil 开发工具及Keil工程简介
2.1Keil开发工具
Keil MDK提供了针对ARM系列芯片的汇编器、C/C++的编译器和一个能进行工程管理的IDE。同时，该软件还支持JLink在线调试，是进行嵌入式软件开发非常优秀的软件。
2.2 Keil工程简介
Keil MDK可以建立针对具体芯片的工程，根据选定的ARM芯片自动生成启动代码，负责硬件的基本初始化和C语言运行环境以及C语言库的初始化。提供工程文件管理，整体编译、链接、调试。Keil MDK工程还可以编制链接文件，链接器会根据编制的链接文件进行链接二进制文件，用来满足嵌入式开发的不同硬件平台需求。
2.3 链接文件、启动文件分析
ARM芯片运行模式和堆栈相关知识都对理解UCOS的任务切换都有很大的帮助，因此我们首先应该理解芯片运行模式和堆栈的概念。理解这些概念最好的方式是分析一下系统启动代码。
在分析启动代码之前，先理解一下Keil MDK 工程中Scf链接文件的相关知识。我们知道源代码程序经过编译、链接后生成一个二进制文件，这个二进制文件是用来控制ARM芯片的。
这个二进制文件是直接下载到ARM处理器芯片的，这个二进制文件的格式如图2.4-1 ARM Image映像文件结构。

图2.4-1 ARM Image映像文件结构

ZI段表示初始化为0的变量区域，RW段表示已经初始化的变量区域，RO段表示代码区域。

因ZI段只是初始化为0的变量区域，所以在Image文件中并不占空间，映像文件中只是包含实际地址和大小。我们一般将image映像文件下载到ROM中，系统启动时从ROM中读取第一条需要执行的指令，但RW段下载到了ROM中，ROM是不可写的。因此出现了装载地址和运行地址不一致的情况。我们要保证程序正常运行就必须保证变量在访问之前放到了正确的地址。一个简单的装载地址到运行地址的转换见图2.4-2 简单的分散装载内存映像图。

图2.4-2  简单的分散装载内存映像图

在KeilMDK工程中使用分散装载文件scf文件来设置映像文件的转载地址和运行地址，当我们设置的转载地址和运行地址不一致时，KeilMDK会自动产生搬运代码，在使用RW、ZI段之前将代码搬运到正确的地址。

我们工程使用的分散加载文件内容：

ROM_LOAD 0x80000000

{

ROM_EXEC 0x80000000

{

      Startup.o (vectors, +First)

      * (+RO)

}

IRAM 0x40000000

{

      Startup.o (MyStacks)

}

STACKS_BOTTOM +0 UNINIT

{

      Startup.o (StackBottom)

}

STACKS 0x40004000 UNINIT

{

      Startup.o (Stacks)

}

ERAM 0x81000000

{

      * (+RW,+ZI)

}

HEAP +0 UNINIT

{

      Startup.o (Heap)

}

HEAP_BOTTOM 0x81080000 UNINIT

{

      Startup.o (HeapTop)

}

}

此分散加载文件只有一个装载域ROM_LOAD，装载地址是0x80000000，这个地址是ARM芯片外的一个NorFlash芯片的起始地址。存在ROM_EXEC、IRAM、STACKS_BOTTOM、STACKS、ERAM、HEAP、HEAP_BOTTOM共8个运行域，每个运行域都有自己的运行地址。其中ROM_EXEC运行域和装载域地址一样，此运行域包含系统的启动代码和所有RO段代码。剩余其他运行域的地址和装载域都不同，都需要根据分散加载文件进行代码搬运工作，这个工作是由KeilMDK工具自动完成。

系统启动代码主要完成的工作如下：

1.    中断向量表

2.    初始化总线频率和存储器系统

3.    初始化堆栈

4.    呼叫主应用程序

中断向量表是当外部中或系统异常发生时中断服务程序的入口地址或存放中断服务程序的首地址。此工程中将中断向量表定位在0x80000000这个地址开始的地方。

AREA vectors,CODE,READONLY

ENTRY

;interrupt vectors

Reset

      LDR PC, ResetAddr

      LDR PC, UndefinedAddr

   LDR    PC, SWI_Addr

      LDR PC, PrefetchAddr

      LDR PC, DataAbortAddr

      DCD 0xb9205f80

      LDR PC, [PC, #-0xff0]

      LDR PC, FIQ_Addr

ResetAddr          DCD    ResetInit

UndefinedAddr    DCD Undefined

SWI_Addr          DCD    SoftwareInterrupt

PrefetchAddr       DCD PrefetchAbort

DataAbortAddr       DCD    DataAbort

Nouse             DCD    0

IRQ_Addr          DCD 0

FIQ_Addr          DCD FIQ_Handler

初始化总线频率以满足各个BANK外接的设备正常使用，一个复杂的系统可能存在多种存储器类型的接口，需要根据实际的系统设计对此加以正确配置。对同一种存储器类型来说，也因为访问速度的差异，需要不同的时序设置。工程中我们使用的存储器包括NorFlash和SRAM，设置的访问总线宽度都为16bit。

堆栈空间是C语言正常运行所需要的基本环境，函数调用参数、返回值、函数调用关系都需要使用堆栈。因此，需要设置ARM各个运行模式的堆栈空间。

InitStack

      MOV R0, LR

;Build the SVC stack

      MSR CPSR_c, #0xd2

      LDR    SP, StackIrq

;Build the FIQ stack

      MSR CPSR_c, #0xd1

      LDR    SP, StackFiq

;Build the DATAABORT stack

      MSR CPSR_c, #0xd7

      LDR    SP, StackAbt

;Build the UDF stack

      MSR CPSR_c, #0xdb

      LDR    SP, StackUnd

;Build the SYS stack

      MSR CPSR_c, #0xdf

      LDR    SP, =StackUsr

      BX    R0

调用__main()函数，此函数主要工作流程如图2.4-3  __main 函数执行流程。

图2.4-3 __main 函数执行流程

调用__user_setup_stackheap()设置用户模式下的栈空间和堆空间。空间可以通过程序定义，也可以通过分散加载文件制定绝对地址空间。
调用__rt_lib_init()初始化库函数，在必要时为用户main函数设置argc、argv参数。调用__cpp_initialize__aeabi_初始化C++特性。
Calls main(), the user-level root of the application.
From main(),your program might call, among other things, library functions.

调用用户main函数，在main函数里，你可以调用其他用户函数，也可以调用库函数。

Calls exit() with the value returned by main().
当main函数返回时，调用exit函数清理资源。

只看该作者 · 2019-3-30 17:42

3. UCOS移植
3.1 ucos简介
UCOS是一个可裁剪、支持抢占式调度的实时嵌入式操作系统。提供基本的任务管理功能，支持信号量、邮箱、队列等任务间同步、通讯机制。

3.2 ucos移植总述
Ucos移植主要是实现保存、恢复ARM芯片执行程序所需要的寄存器环境和实现系统时钟接口需要的硬件定时器的设置及启动。需要移植实现的主要有任务级任务切换、中断级任务切换、任务堆栈初始化、系统时钟。

3.3 和移植UCOS有关的ARM芯片知识
C语言经过编译器编译、链接后生成的二进制指令是能在ARM芯片上直接执行的指令代码。这些指令执行是依赖于各种寄存器的，保护程序运行环境其实就是保护这些寄存器。

ARM芯片有7种运行模式：

1.    用户模式（user模式），运行应用的普通模式。

2.    快速中断模式（fiq模式），用于支持数据传输或通道处理。

3.    中断模式（irq模式），用于普通中断处理。

4.    超级用户模式（svc模式），操作系统的保护模式。

5.    异常中断模式（abt模式）,输入数据后登入或预取异常中断指令。

6.    系统模式（sys模式），是操作系统使用的一个有特权的用户模式。

7.    未定义模式（und模式），执行了未定义指令时进入该模式。

外部中断，异常操作或软件控制都可以改变中断模式。大多数应用程序都时是在用户模式下运行。进入特权模式是为了处理中断或异常请求或操作保护资源服务的。

些工作模式是芯片硬件提供的程序运行的不同环境，不同的模式有不同的硬件访问权限，使用不同的寄存器。这就给不同的程序提供了不同的权限机制，你比如说你的操作系统代码运行在权限比较高的模式下，而你的应用程序运行在权限比较低的模式下。这样就起到了对操作系统代码的保护作用。

寄存器，各个模式下可见的寄存器以及各个寄存器的功能：

ARM共有37个32位的寄存器，其中31个是通用寄存器，6个是状态寄存器。但在同一时间，对程序员来说并不是所有的寄存器都可见。在某一时刻存储器是否可见（可被访问），是处理器当前的工作状态和工作模式决定的。其各个模式下的寄存器如图3.3-1  ARM各种运行模式：

图3.3-1  ARM各种运行模式

其中系统模式和用户模式所用的寄存器是一样的。画三角阴影的寄存器表示在不同模式下有不同的物理寄存器。

以下对其进行分类说明。

通用寄存器：

ARM的通用寄存器包括R0~R15,其中R0~R7是属于未分组寄存器，各个模式下都使用同样的寄存器。R8~R14在FIQ模式下是有独立的物理寄存器，其目的是加快中断响应速度，从硬件上保存程序执行现场。R13和R14这两个寄存器在每种模式下都有自己的独立寄存器。R15只有一个，所有模式公用。

下对这些寄存器中的比较有特殊功能的做一下介绍：

寄存器R13:在ARM指令中，常用R13做堆栈指针用。每种运行模式都有自己独立的堆栈，用于保存中断发生时的程序运行环境和C语言执行时进行过程控制。

寄存器R14：专职持有返回点的地址，在系统执行一条“跳转并链接（link）”（BL）指令

的时候，R14将收到一个R15的拷贝。其他的时候，它可以用作一个通用寄存器。相应的它在其他模式下的私有寄存器R14_svc，R14_irq，R14_fiq，R14_abt和R14_und都同样用来保存在中断或异常发生时，或时在中断和异常中执行了BL指令时，R15的返回值。

寄存器R15是程序计数器（PC）。在ARM状态下，R15的bits[1:0]为0，bits[31:2]保存了PC的值。在Thumb状态下，bits[0]为0同时bits[31:1]保存了PC值。

FIQ模式拥有7个私有寄存器R8-14（R8_fiq-R14_fiq）。在ARM状态下，多数FIQ处理都不需要保存任何寄存器。用户、中断、异常中止，超级用户和未定义模式都拥有2个私有寄存器，R13和R14。允许这些模式都可拥有1个私有堆栈指针和链接（link）寄存器。

程序状态寄存器。

ARM920T具有一个当前程序状态寄存器（CPSR），另外还有5个保存程序状态寄存器（SPSRs）用于异常中断处理。这些寄存器的功能有：

1.    保留最近完成的ALU操作的信息。

2.    控制中断的使能和禁止。

3.    设置处理器的操作模式。

状态寄存器各位定义见图3.3-2  ARM状态寄存器：

图3.3-2 ARM状态寄存器

只看该作者 · 2019-3-30 17:42

3.4 系统堆栈和UCOS的任务堆栈
当产生外部中断或者系统异常时，ARM会进入相应的模式，各种运行模式均有其独立的堆栈空间。UCOS中的任务是调度的最小单元，每个任务都有自己独立的堆栈空间，当任务运行时，它用来保存一些局部变量，当任务挂起时，它负责保存任务的运行现场，也就是CPU寄存器的值。

3.5 系统时钟
系统时钟是UCOS管理任务延时的基本依据，要求有一个周期性的定时器产生固定间隔时间。我们使用LPC2220的定时器0产生固定时间间隔事件，时间间隔设置为10ms，定时时间到产生中断。UCOS系统时钟处理函数是OSTimeTick()，时间中断服务程序里调用此函数即可。

只看该作者 · 2019-3-30 17:43

3.6 任务级任务切换
UCOS的用户调用一些系统服务时（比如，OSTimeDly、OSSemPend），就会产生任务级任务切换。其切换的实质是保存正在执行任务的执行现场，然后恢复应该运行的任务的运行现场。
本工程中使用软中断的方式实现任务级任务切换的目的。
任务级切换函数的底层接口是使用的软中断技术，用__swi来声明一个不存在的函数，则调用这个函数就在调用这个函数的地方插入一条SWI指令，并且可以指定功能号。定义如下：__swi(0x00) void OS_TASK_SW(void);       /*  任务级任务切换函数       */
调用OS_TASK_SW()这个函数时就会产生一个软中断，产生软中断后执行软中断服务程序。服务程序主要代码分析如下：
SoftwareInterrupt
      LDR    SP, StackSvc          ; 重新设置堆栈指针
      STMFD SP!, {R0-R3, R12, LR}
      MOV    R1, SP             ; R1指向参数存储位置

      MRS    R3, SPSR
      TST    R3, #T_bit             ; 中断前是否是Thumb状态
      LDRNEH  R0, [LR,#-2]          ; 是: 取得Thumb状态SWI号
      BICNE R0, R0, #0xff00
      LDREQ R0, [LR,#-4]          ; 否: 取得arm状态SWI号
      BICEQ R0, R0, #0xFF000000
                                    ; r0 = SWI号，R1指向参数存储位置
      CMP    R0, #1
      LDRLO PC, =OSIntCtxSw
      LDREQ PC, =__OSStartHighRdy ; SWI 0x01为第一次任务切换

      BL    SWI_Exception

      LDMFD SP!, {R0-R3, R12, PC}^
代码难点分析：
软中断指令使处理器进入管理模式，而用户程序处于系统／用户模式，其它异常也有自己的处理器模式，都有各自的堆栈指针，不会因为给堆栈指针赋值而破坏其它处理器模式的堆栈而影响其它程序的执行。返回的地址已经存储在连接寄存器LR中而不是存储在堆栈中。由于进人管理模式自动关中断，所以这段程序不会被其它程序同时调用。
因为ARM处理器核具有两个指令集，在执行Thumb指令的状态时不是所有寄存器都可见（参考ARM的相关资料），而且任务又可能不在特权模式（不能改变CPSR）。为了兼容任意一种模式，本移植使用软中断指令SWI使处理器进入管理模式和ARM指令状态，并使用功能0实现OS_TASK_SW（）的功能。
因任务级任务切换使用的是软中断技术，我们把osctxsw（）与osintctxsw（）合二为一了，统一采用osintctxsw（）来实现。之所以这样搞的原因是任务进行切换的时候，都必须进入软中断的状态，而对于软中断的异常响应代码已经将任务的环境变量进行了保存，从而也不需要像osctxsw（）里面规定的那样对将环境变量进行保存。osintctxsw（）函数的移植分析见3.7中断级任务切换。
3.7 中断级任务切换
当系统任务延时时间到或者在中断服务程序里抛出信号量、邮箱等可以产生系统调度的操作时，会执行任务切换，但这种切换是在中断模式下进行的。但底层切换函数是一致的，只不过任务级任务切换时是在SVC模式下进行，中断级任务切换是在中断模式下进行。
下面我们分析中断级任务切换的主要流程和代码：
      SUB LR, LR, #4                   ; 计算返回地址
      STMFD SP!, {R0-R3, R12, LR}  ; 保存任务环境
      MRS    R3, SPSR             ; 保存状态
      STMFD SP, {R3,SP, LR}^; 保存用户状态的R3,SP,LR,注意不能回写
                           ; 如果回写的是用户的SP，所以后面要调整SP
      LDR    R2,  =OSIntNesting    ; OSIntNesting++
      LDRB R1, [R2]
      ADD    R1, R1, #1
      STRB R1, [R2]

      SUB    SP, SP, #4*3

      MSR    CPSR_c, #(NoInt :OR: SYS32Mode)  ; 切换到系统模式
      CMP    R1, #1
      LDREQ SP, =StackUsr

      BL    $IRQ_Exception_Function ; 调用c语言的中断处理程序

      MSR    CPSR_c, #(NoInt :OR: SYS32Mode)  ; 切换到系统模式
      LDR    R2, =OsEnterSum; OsEnterSum,使OSIntExit退出时中断关闭
      MOV    R1, #1
      STR    R1, [R2]

      BL    OSIntExit

      LDR    R2, =OsEnterSum; 因为中断服务程序要退出，
;所以OsEnterSum=0
      MOV    R1, #0
      STR    R1, [R2]

      MSR    CPSR_c, #(NoInt :OR: IRQ32Mode) ; 切换回irq模式
      LDMFD SP, {R3,SP, LR }^    ; 恢复用户状态的R3,SP,LR,
;注意不能回写
   ; 如果回写的是用户的SP，所以后面要调整SP
      LDR    R0, =OSTCBHighRdy
      LDR    R0, [R0]
      LDR    R1, =OSTCBCur
      LDR    R1, [R1]
      CMP    R0, R1

      ADD    SP, SP, #4*3                   ;
      MSR    SPSR_cxsf, R3
      LDMEQFD SP!, {R0-R3, R12, PC}^       ; 不进行任务切换
      LDR    PC, =OSIntCtxSw                ; 进行任务切换

代码主要功能分析：
实现在中断模式下保存系统模式下正在运行任务的各个寄存器到中断模式堆栈，然后执行相应的中断服务程序，中断退出时做任务切换。
下面我们分析实现任务切换的函数OSIntCtxSw。
OSIntCtxSw
                                             ;下面为保存任务环境
      LDR    R2, [SP, #20]                   ;获取PC
      LDR    R12, [SP, #16]                ;获取R12
      MRS    R0, CPSR

      MSR    CPSR_c, #(NoInt :OR: SYS32Mode)
      MOV    R1, LR
      STMFD SP!, {R1-R2}                      ;保存LR,PC
      STMFD SP!, {R4-R12}                      ;保存R4-R12

      MSR    CPSR_c, R0
      LDMFD SP!, {R4-R7}                      ;获取R0-R3
      ADD    SP, SP, #8                         ;出栈R12,PC

      MSR    CPSR_c, #(NoInt :OR: SYS32Mode)
      STMFD SP!, {R4-R7}                      ;保存R0-R3

      LDR    R1, =OsEnterSum                   ;获取OsEnterSum
      LDR    R2, [R1]
      STMFD SP!, {R2, R3} ;保存CPSR,OsEnterSum

                              ;保存当前任务堆栈指针到当前任务的TCB
      LDR    R1, =OSTCBCur
      LDR    R1, [R1]
      STR    SP, [R1]
      BL    OSTaskSwHook ;调用钩子函数
                                    ;OSPrioCur <= OSPrioHighRdy
      LDR    R4, =OSPrioCur
      LDR    R5, =OSPrioHighRdy
      LDRB R6, [R5]
      STRB R6, [R4]
                                    ;OSTCBCur <= OSTCBHighRdy
      LDR    R6, =OSTCBHighRdy
      LDR    R6, [R6]
      LDR    R4, =OSTCBCur
      STR    R6, [R4]
上述函数实现了保存上一个被中断任务运行时各个寄存器到任务的堆栈空间里，然后将系统中优先级最高且就绪的任务堆栈里保存的各个寄存器内容恢复到系统模式的各个寄存器中，使任务正常运行。

只看该作者 · 2019-3-30 17:44

4.Lwip移植
4.1 lwip简介
lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。LwIP是Light Weight (轻型)IP协议，有无操作系统的支持都可以运行。LwIP实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用，它只需十几KB的RAM和40K左右的ROM就可以运行，这使LwIP协议栈适合在低端的嵌入式系统中使用。
4.2 lwip移植总述
Lwip有无操作系统的支持都可以运行，我们移植是基于UCOS的。
基于UCOS移植Lwip主要包含两个方面的工作：
1. 根据Lwip提供的操作系统模拟层接口编写基于UCOS的实现代码，以实现Lwip和UCOS的完美融合。
2. 根据Lwip提供的底层网卡驱动接口，结合RTL8019AS网卡datasheet编制网卡驱动程序。
4.3移植lwip操作系统模拟层
操作系统模拟层（sys_arch）存在的目的主要是为了方便 LwIP 的移植，它在底层操作系统和LwIP 之间提供了一个接口。这样，我们在移植 LwIP 到一个新的目标系统时，只需修改这个接口即可。不过，不依赖底层操作系统的支持也可以实现这个接口。
sys_arch需要为LwIP提供创建新线程功能，提供信号量（semaphores）和邮箱（mailboxes）两种进程间通讯方式（IPC）。
1. 模拟层需要添加的头文件 cc.h 说明
Lwip使用的数据类型定义：
typedef unsigned char    u8_t;
typedef signed char       s8_t;
typedef unsigned short u16_t;
typedef signed short s16_t;
typedef unsigned int    u32_t;
typedef signed int    s32_t;
typedef unsigned int sys_prot_t;
typedef unsigned int  mem_ptr_t;
lwip使用的结构体对齐方式声明相关的宏定义：
#define PACK_STRUCT_FIELD(x) x
#define PACK_STRUCT_STRUCT
#define PACK_STRUCT_BEGIN  __packed
#define PACK_STRUCT_END
为方便操作协议帧数据，lwip协议栈中结构体使用单字节对齐方式。
处理器模式：
#define BYTE_ORDER LITTLE_ENDIAN
我们使用的LPC2220为小端模式处理器，故定义为小端模式。
其他内容主要和调试输出功能有关，这里不进行一一说明。
2. 需要实现的操作系统模拟层函数
- void sys_init(void)

  初始化lwip操作系统模拟层。

- sys_sem_t sys_sem_new(u8_t count)

  创建一个信号量，count表示初始化后的信号量状态。

- void sys_sem_free(sys_sem_t sem)

  删除指定的信号量。

- void sys_sem_signal(sys_sem_t sem)

发送一个信号量。

- u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
等待指定的信号并阻塞线程。timeout 参数为 0，线程会一直被阻塞至收到指定的信号；非 0，则线程仅被阻塞至指定的 timeout时间（单位为毫秒）。在timeout 参数值非 0 的情况下，返回值为等待指定的信号所消耗的毫秒数。如果在指定的时间内并没有收到信号，返回值为SYS_ARCH_TIMEOUT。如果线程不必再等待这个信号（也就是说，已经收到信号），返回值也可以为 0。注意，LwIP实现了一个名称与之相似的函数来调用这个函数，sys_sem_wait()，注意区别。
- sys_mbox_t sys_mbox_new(void)
  创建一个空消息邮箱。

- void sys_mbox_free(sys_mbox_t mbox)
释放一个邮箱。

- void sys_mbox_post(sys_mbox_t mbox, void *msg)
投递消息“msg”到指定的邮箱“mbox” 。

- u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout)
   阻塞线程直至邮箱收到至少一条消息。最长阻塞时间由 timeout 参数指定（与
sys_arch_sem_wait()函数类似）。msg 是一个结果参数，用来保存邮箱中的消息指针（即*msg  = ptr），它的值由这个函数设置。 “msg”参数有可能为空，这表明当前这条消息应该被丢弃。返回值与 sys_arch_sem_wait()函数相同：等待的毫秒数或者 SYS_ARCH_TIMEOUT――如果时间溢出的话。LwIP实现的函数中，有一个名称与之相似的――sys_mbox_fetch()，注意区分。

- struct sys_timeouts *sys_arch_timeouts(void)
   返回一个指向当前线程使用的 sys_timeouts 结构的指针。LwIP 中，每一个线程都有一个timeouts 链表，这个链表由 sys_timeout 结构组成，sys_timeouts 结构则保存了指向这个链表的指针。这个函数由 LwIP 的超时调度程序调用，并且不能返回一个空（NULL）值。单线程 sys_arch 实现中，这个函数只需简单返回一个指针即可。这个指针指向保存在 sys_arch 模块中的 sys_timeouts 全局变量。

- sys_thread_t sys_thread_new(void (* thread)(void *arg), void *arg, int prio)

创建一个新的线程。

实现sys_sem_t sys_sem_new(u8_t count)函数：
sys_sem_t sys_sem_new(u8_t count)
{
return OSSemCreate((u16_t)count);
}
这个函数实现比较简单，UCOS提供了信号量的操作函数，直接调用即可。
实现void sys_sem_free(sys_sem_t sem)函数：
void sys_sem_free(sys_sem_t sem)
{
u8_t Err;
OSSemDel(sem, OS_DEL_ALWAYS, &Err);
}
实现void sys_sem_signal(sys_sem_t sem)函数：
void sys_sem_signal(sys_sem_t sem)
{
OSSemPost(sem);
}
实现u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)函数：
u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
{
u8_t Err;
u32_t wait_ticks;

if (OSSemAccept(sem))/* 如果已经收到, 则返回0 */
{
return 0;
}

wait_ticks = 0;
if(timeout!=0){
  wait_ticks = (timeout * OS_TICKS_PER_SEC)/1000;
  if(wait_ticks < 1)
   wait_ticks = 1;
   else if(wait_ticks > 65535)
         wait_ticks = 65535;
}

OSSemPend(sem, (u16_t)wait_ticks, &Err);

if (Err == OS_NO_ERR)
return timeout/2;    //将等待时间设置为timeout/2
else
return SYS_ARCH_TIMEOUT;
}
阻塞进程，等待一个信号量的到来。如果timeout不为0，则进程阻塞的时间最多为相关的毫秒数，否则进程一直阻塞，直到收到信号量。
返回值：如果timeout不为0，则返回值为等待该信号量的毫秒数，如果函数在规定的时间内没有等到信号量，则返回值为SYS_ARCH_TIMEOUT，如果信号量在调用函数时已经可用，则函数不会发生任何阻塞操作，返回值这时可以是0。
实现sys_mbox_t sys_mbox_new(int size)函数功能：
sys_mbox_t sys_mbox_new(int size)
{
u8_t    Err;
sys_mbox_t pQDesc;

pQDesc = OSMemGet( MboxMem, &Err );
if( Err == OS_NO_ERR ) {
      pQDesc->ucos_queue = OSQCreate( &(pQDesc->mbox_msg_entris[0]), MAX_MSG_IN_MBOX );
      if( pQDesc->ucos_queue != NULL ) {
         return pQDesc;
      }
      else{
         OSMemPut(MboxMem,pQDesc);
      }
}
return SYS_MBOX_NULL;
}
邮箱用于消息传递，用户即可以将其实现为一个队列，允许多条消息投递到这个邮箱，也可以每次只允许投递一个消息，这两种方式 LwIP都可以正常运作。不过，前者更加有效。这里我们使用消息队列的方式，允许投递多条消息。
实现void sys_mbox_free(sys_mbox_t mbox)函数：
void sys_mbox_free(sys_mbox_t mbox)
{
u8_t Err;

OSQFlush(mbox->ucos_queue);

OSQDel(mbox->ucos_queue, OS_DEL_ALWAYS, &Err);

OSMemPut( MboxMem, mbox );
}
实现void sys_mbox_post(sys_mbox_t mbox, void *msg)函数功能：
void sys_mbox_post(sys_mbox_t mbox, void *msg)
{
if (msg == NULL)
msg = (void*)&NullMessage;//解决空指针投递的问题
while (OSQPost(mbox->ucos_queue, msg) == OS_Q_FULL)
  OSTimeDly(10);
}
实现u32_t
sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout)函数：
u32_t
sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout)
{
u8_t Err;
u32_t wait_ticks;
void *Data;

Data = OSQAccept(mbox->ucos_queue);
if (Data != NULL)
{
      if (Data == (void*)&NullMessage)
      {
         *msg = NULL;
      }
      else
      {
         *msg = Data;
      }
return 0;
}

wait_ticks = 0;
if(timeout!=0){
  wait_ticks = (timeout * OS_TICKS_PER_SEC)/1000;
  if(wait_ticks < 1)
   wait_ticks = 1;
   else if(wait_ticks > 65535)
         wait_ticks = 65535;
}

Data = OSQPend(mbox->ucos_queue, (u16_t)wait_ticks, &Err);

if (Data != NULL)
{
      if (Data == (void*)&NullMessage)
      {
         *msg = NULL;
      }
      else
      {
         *msg = Data;
      }
}

if (Err == OS_NO_ERR)
return timeout/2;    //将等待时间设置为timeout/2
else
return SYS_ARCH_TIMEOUT;
}
实现struct sys_timeouts * sys_arch_timeouts(void)函数功能：
struct sys_timeouts * sys_arch_timeouts(void)
{
  return &global_timeouts;
}
实现sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio)函数功能：
sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio)
{
  static u32_t TaskCreateFlag=0;
  u8_t i=0;
  name=name;
  stacksize=stacksize;

  while((TaskCreateFlag>>i)&0x01){
if(i<LWIP_MAX_TASKS&&i<32)
      i++;
else return 0;
  }
  if(OSTaskCreate(thread,(void*)arg, &LWIP_STK_AREA[i][LWIP_STK_SIZE-1],prio)==OS_NO_ERR){
   TaskCreateFlag |=(0x01<<i);
  };

  return prio;
}
新建一个进程，在整个系统中只会被调用一次。
移植操作系统模拟层完成。

只看该作者 · 2019-3-30 17:45

4.4 根据lwip提供的软件架构编写相应的网卡芯片驱动
从用户编程角度看，针对RTL8019AS的操作实际上就是对RTL8019AS内部寄存器的操作，以实现网卡的初始化、数据发送、数据接收等操作。发送数据时，主控制器将数据写入网卡的SRAM中，然后发送一个发送数据指令，网卡就会将数据封装成标准以太网物理层数据帧发送出去。同理，网卡接收到以太网数据时，网卡会自动解析成高层使用的有效格式，放在内部SRAM中供主控芯片读取，我们采用周期查询方式实现接收数据的处理。
RTL8019AS与主控芯片间通讯的输入/输出地址共有32个，地址偏移量为00H-1FH。其中00-0F共16个地址，为内部寄存器地址，RTL8019AS的内部寄存器每个都是8位的，所有寄存器一共分为4页，每一页都共享这16个偏移量，当前那一页有效是由CR寄存器的值决定的。

要接收和发送数据包都必须读写网卡的内部的16k的ram,必须通过DMA进行读和写.网卡的内部ram是一块双端口的16k字节的ram.所谓双端口就是说有两套总线连结到该ram,一套总线A是网卡控制器读/写网卡上的ram,另一套总线B是主控制器读/写网卡上的ram.总线A又叫Local DMA,总线B又叫Remote DMA.
远程DMA地址包括10H～17H，都可以用来做远程DMA端口，只要用其中的一个就可以了。我们使用10H。
复位端口包括18H～1FH共8个地址，功能一样，用于RTL8019AS复位。我们使用18H。

Lwip提供了网卡驱动框架形式，我们只要根据实际使用的网卡特性完善这些函数就可以了。
具体说我们应该实现以5个函数的实现。
static void low_level_init(struct netif *netif)。
static err_t low_level_output(struct netif *netif, struct pbuf *p)
static struct pbuf *low_level_input(struct netif *netif)
err_t ethernetif_init(struct netif *netif)
static void ethernetif_input(struct netif *netif)
前3个函数与网卡驱动函数密切相关。low_level_init为网卡初始化函数，主要用来完成网卡的复位及参数初始化。low_level_output为网卡数据包发送函数。low_level_input为网卡数据包接收函数。
ethernetif_input函数主要作用是调用网卡数据包接收函数low_level_input从网卡SRAM中读取一个数据包，然后解析数据包类型，然后交付给上层应用程序。实际上，ethernetif_input已经是一个可以直接使用的函数，调用一次可以完成数据包的接收和递交。我们在应用层建立一个任务周期性调用该函数实现接收数据包的功能。
ethernetif_init是上层应用在管理网络接口结构netif时调用的函数。该函数主要完成netif结构中的某些字段初始化，并最终调用low_level_init函数完成网卡的初始化。
low_level_init函数实现源代码：
static void
low_level_init(struct netif *netif)
{
  struct ethernetif *ethernetif = netif->state;

  /* set MAC hardware address length */
  netif->hwaddr_len = ETHARP_HWADDR_LEN;

  /* set MAC hardware address */
  netif->hwaddr[0] = MyMacID[0];
  netif->hwaddr[1] = MyMacID[1];
  netif->hwaddr[2] = MyMacID[2];
  netif->hwaddr[3] = MyMacID[3];
  netif->hwaddr[4] = MyMacID[4];
  netif->hwaddr[5] = MyMacID[5];

  /* maximum transfer unit */
  netif->mtu = 1500;

  /* device capabilities */
  /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
  netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;

  /* Do whatever else is needed to initialize interface. */
  board_eth_init();
}
netif结构体是协议栈内核对系统网络接口设备进行管理的重要数据结构，内核会为每个网络接口分配一个netif结构，用于描述接口属性。上面函数初始化了hwaddr、mtu、flag等关键属性域，并最后调用board_eth_init函数。
board_eth_init函数源代码如下：
void board_eth_init(void)
{
unsigned char  i;
unsigned char  j;

IODIR=IODIR|RSTDRV;
IOCLR=RSTDRV;
for(i=0;i<200;i++)
{
for(j=0;j<200;j++);
}
IOSET=RSTDRV;
for(i=0;i<200;i++)
{
for(j=0;j<200;j++);
}
IOCLR=RSTDRV;
for(i=0;i<200;i++)
{
for(j=0;j<200;j++);
}

NE_RESET = 0x12;
Delay(500);
NE_CR = ENCR_PAGE0 + ENCR_NODMA;
  NE_DCR = NE_DCRVAL;
  NE_RBCR0 = 0x00;
/* MSB remote byte count reg */
  NE_RBCR1 = 0x00;
/* LSB remote byte count reg */
  NE_TPSR = TX_START_PG;
  NE_PSTART = RX_START_PG ; /* DMA START PAGE 46h */
  NE_PSTOP  = RX_STOP_PG;    /* Ending page +1 of ring buffer */
  NE_BNRY = RX_START_PG;/* Boundary page of ring buffer */
  NE_RCR = ENRCR_RXCONFIG;
  NE_TCR = ENTCR_TXCONFIG; /* xmit on. */
  NE_ISR = 0xff;
/* Individual bits are cleared by writing a "1" into it. */
  NE_IMR = ENIMR_RX;             // by Forrest..
  NE_CR = ENCR_PAGE1 + ENCR_NODMA;
  NE_PAR0 = MyMacID[0];
  NE_PAR1 = MyMacID[1];
  NE_PAR2 = MyMacID[2];
  NE_PAR3 = MyMacID[3];
  NE_PAR4 = MyMacID[4];
  NE_PAR5 = MyMacID[5];
  NE_MAR0 = 0xff;
  NE_MAR1 = 0xff;
  NE_MAR2 = 0xff;
  NE_MAR3 = 0xff;
  NE_MAR4 = 0xff;
  NE_MAR5 = 0xff;
  NE_MAR6 = 0xff;
  NE_MAR7 = 0xff;
  NE_CURR = RX_START_PG; /* RX_CURR_PG; Current memory page = RX_CURR_PG  ? */


  NE_CR = ENCR_PAGE0 + ENCR_NODMA + ENCR_START;
}
board_eth_init函数是保证网卡RTL8019AS正常工作的前提，它首先完成网卡的硬件复位，然后进**的软件复位（往0X18端口写入任意值使其软复位），接着初始化网卡配置中的发送、接收缓冲区的页地址、配置了网卡发送配置寄存器、接收寄存器，最后设置网卡自身的物理地址和多播过滤地址。
low_level_output函数，上层应用层数据需要封装成协议栈要求的pbuf数据格式，然后再操作网卡发送数据。其源代码如下：
static err_t
low_level_output(struct netif *netif, struct pbuf *p)
{
  struct pbuf *q;

  u8_t isr;
  u8_t chain=0;
  u8_t * tr_ptr;
  u16_t tr_len, temp_dw;
  u16_t padLength,packetLength;

  /* Set up to transfer the packet contents to the NIC RAM. */
  padLength = 0;
  packetLength = p->tot_len;

  /* packetLength muse >=64 (see 802.3) */
  if ((p->tot_len) < 64)
  {
padLength = 64 - (p->tot_len);
packetLength = 64;
  }

  /* don't close nic,just close receive interrupt */
  NE_CR = ENCR_PAGE2 | ENCR_NODMA | ENCR_START;
  isr = NE_IMR;
  isr &= ~ENISR_RX;
  NE_CR = ENCR_PAGE0 | ENCR_NODMA | ENCR_START;
  NE_IMR = isr;

  NE_ISR = ENISR_RDC;

  /* Amount to send */
  NE_RBCR0 = packetLength & 0xff;
  NE_RBCR1 = packetLength >> 8;

  /* Address on NIC to store */
  NE_RSAR0 = 0x00;
  NE_RSAR1 = NE_START_PG;

  /* Write command to start */
  NE_CR = ENCR_PAGE0 | ENCR_RWRITE | ENCR_START;

  /* write packet to ring buffers. */
  for(q = p, chain = 0; q != NULL; q = q->next)
  {
if(chain == 1)
{
   if(((q->len-1) & 0x01) && (q->next != NULL))
   {
tr_len = q->len - 2;
tr_ptr = ((u8_t*)q->payload) + 1;

temp_dw = *(((u8_t *)q->payload) + q->len - 1);
temp_dw += *(u8_t *)(q->next->payload) << 8;

chain = 1;
}
else
{
tr_len = q->len - 1;
tr_ptr = ((u8_t*)q->payload) + 1;
chain = 0;
}
}
else
{
if((q->len & 0x01) && (q->next != NULL))
{
tr_len = q->len - 1;
tr_ptr = (u8_t*)q->payload;

temp_dw = *(((u8_t *)q->payload) + q->len - 1);
temp_dw += *(u8_t *)(q->next->payload) << 8;

chain = 1;
}
else
{
tr_len = q->len;
tr_ptr = (u8_t*)q->payload;

chain = 0;
}
}

ne2k_copyout(tr_len, tr_ptr);

if (chain == 1) NE_DATAW = temp_dw;

  }
if(padLength>0)
ne2k_outpad(padLength);

  /* Wait for remote dma to complete - ISR Bit 6 clear if busy */
  while((u8_t)(NE_ISR & ENISR_RDC) == 0 );

  /* clear RDC */
  NE_ISR = ENISR_RDC;

  /* Issue the transmit command.(start local dma) */
  NE_TPSR = NE_START_PG;
  NE_TBCR0 = packetLength & 0xff;
  NE_TBCR1 = packetLength >> 8;

  /* Start transmission (and shut off remote dma) */
  NE_CR = ENCR_PAGE0 | ENCR_NODMA | ENCR_TRANS | ENCR_START;
  /* reopen receive interrupt */
  NE_CR = ENCR_PAGE2 | ENCR_NODMA | ENCR_START;
  isr = NE_IMR;
  isr |= ENISR_RX;
  NE_CR = ENCR_PAGE0 | ENCR_NODMA | ENCR_START;
  NE_IMR = isr;

#ifdef LINK_STATS
  lwip_stats.link.xmit++;
#endif /* LINK_STATS */

  return ERR_OK;
}
low_level_input函数从网卡读取数据，封装成pbuf形式后传递给上层应用层。其源代码如下：
static struct pbuf *
low_level_input(struct netif *netif)
{
  struct pbuf *p, *q;
  u16_t packetLength, len;
  u8_t PDHeader[18]; /* Temp storage for ethernet headers */
  u8_t * payload;

  NE_ISR = ENISR_RDC;
// NE_RBCR1 = 0x0f; /* See controller manual , use send packet command */
  NE_CR = ENCR_PAGE0 | ENCR_RREAD | ENCR_RWRITE | ENCR_START;
//  NE_CR = ENCR_PAGE0 | ENCR_RREAD | ENCR_START;
  /* get the first 18 bytes from nic */
  ne2k_copyin(18,PDHeader);

  /* Store real length, set len to packet length - header */
  packetLength = ((unsigned) PDHeader[2] | (PDHeader[3] << 8 ));

  /* verify if the packet is an IP packet or ARP packet */
  if((PDHeader[3]>0x06)||(PDHeader[16] != 8)||(PDHeader[17] != 0 && PDHeader[17] != 6))
  {
ne2k_discard(packetLength-14);
return NULL;
  }

  /* We allocate a pbuf chain of pbufs from the pool. */
  p = pbuf_alloc(PBUF_RAW, packetLength, PBUF_POOL);

  if (p != NULL) {
/* We iterate over the pbuf chain until we have read the entire
   packet into the pbuf. */

/* This assumes a minimum pbuf size of 14 ... a good assumption */
memcpy(p->payload, PDHeader + 4, 14);

for(q = p; q != NULL; q = q->next) {
   /* Read enough bytes to fill this pbuf in the chain. The
      available data in the pbuf is given by the q->len
      variable. */
   payload = q->payload;
len = q->len;
if (q == p) {
payload += 14;
len -=14;
}

   ne2k_copyin(len,payload);
}

#ifdef LINK_STATS
lwip_stats.link.recv++;
#endif /* LINK_STATS */
  } else {
/* no more PBUF resource, Discard packet in buffer. */
ne2k_discard(packetLength-14);
#ifdef LINK_STATS
lwip_stats.link.memerr++;
lwip_stats.link.drop++;
#endif /* LINK_STATS */
  }

  return p;
}
Lwip要求的协议栈底层操作网卡的函数编写完毕。

只看该作者 · 2019-3-30 17:46

4.5 移植完成后测试TCP/IP协议栈
我们使用查询方式读取网卡数据包，具体方案是建一个查询任务，周期性调用GetPacket()函数，函数源代码：
void GetPacket(void)
{
u8_t  isr,curr,bnry;

NE_CR = ENCR_PAGE0 | ENCR_NODMA;
isr = NE_ISR;

  /* got packet with no errors */
if (isr & ENISR_RX) {

NE_ISR = ENISR_RX;

NE_CR = ENCR_PAGE1 | ENCR_NODMA;
curr  = NE_CURR;
NE_CR = ENCR_PAGE0 | ENCR_NODMA;
bnry = NE_BNRY;
/* get more than one packet until receive buffer is empty */
while(curr != bnry) {
ethernetif_input(&rtl8019_netif);
   NE_CR = ENCR_PAGE1 | ENCR_NODMA;
   curr =  NE_CURR;
   NE_CR = ENCR_PAGE0 | ENCR_NODMA;
   bnry = NE_BNRY;
}
// rBNRY = NE_BNRY;
  }
  else {
NE_ISR = 0xFF;
  };
}
在测试lwip协议栈前，我们需要初始化。初始化代码：
struct netif rtl8019_netif;
struct netif loop_netif;
extern err_t ethernetif_init(struct netif *netif);

void lwip_init_task(void)
{
struct ip_addr ipaddr, netmask, gw;

tcpip_init(NULL,NULL);
IP4_ADDR(&gw, 192,168,0,1);
IP4_ADDR(&ipaddr, 192,168,0,174);
IP4_ADDR(&netmask, 255,255,255,0);

netif_add(&rtl8019_netif,&ipaddr,&netmask,&gw,NULL,ethernetif_init,tcpip_input);
netif_set_default(&rtl8019_netif);
netif_set_up(&rtl8019_netif);
}
系统ping测试成功如图4.5-1  ping测试：

图4.5-1 ping测试

只看该作者 · 2019-3-30 17:47

4.6 设计并实现简单的WEB服务器
HTTP是一个基于TCP/IP，属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。
通过浏览器访问一个WEB服务器时，其实就是利用HTTP 协议向服务器发送web页面请求，WEB服务器接收到该请求后，返回应答信息和浏览器请求的网页内容。
我们以一个最简单的例子说明一下HTTP协议：
浏览器发送的标准请求是这样的：
1. GET /index.html HTTP/1.1
2. Accept: text/html
3. Accept-Language: zh-cn
4. User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)
5. Connection: Keep-Alive
上面的请求含义：
1. 说明我需要index.html这个网页内容，使用的HTTP协议版本是1.1
2. 我可以接收的文件类型是text/html
3. 我可以接收的语言是中文
4. 浏览器的型号和版本号
5. 需要保持长连接。
服务器的回复信息是这样的：
1. HTTP/1.1 200 OK
2. Date: Sat, 4 Apr 2015 18:54:17 GMT
3. Server: microHttp/1.0 Zlgmcu Corporation
4. Accept-Ranges: bytes
5. Connection: Keep-Close
6. Content-Type: text/html; charset=gb2312
服务器回复的信息含义：
1. 服务器返回浏览器访问的页面存在。
2. 该响应头表明服务器支持Range请求,以及服务器所支持的单位是字节(这也是唯一可用的单位)。
3. 关闭连接
4. 服务器返回的文件类型为text/html，文件编码为gb2312。
基于上述HTTP协议原理，我们可以设计一个简单的WEB服务器，有浏览器访问时WEB服务器返回固定的页面。
在浏览器中输入开发板的IP地址：192.168.0.174
页面显示如图4.6-1 简单WEB服务器：

图4.6-1  简单WEB服务器

浏览器默认访问端口是80，我们开发板使用lwip提供的socket编程接口编程实现监听80端口，有浏览器访问开发板的80端口，开发板向浏览器返回指定WEB页面。
实现代码如下：
void lwip_demo(void *pdata)
{
struct netconn *conn,*newconn;
lwip_init_task();

conn=netconn_new(NETCONN_TCP);
netconn_bind(conn,NULL,80);
netconn_listen(conn);

while(1)
  {
newconn=netconn_accept(conn);
if(newconn!=NULL)
{
  struct netbuf *inbuf;
  char *dataptr;
  u16_t size;
  inbuf = netconn_recv(newconn);
  if(inbuf!=NULL)
  {
      //测试案例
  netbuf_data(inbuf,(void **)&dataptr,&size);
netconn_write(newconn,htmldata,sizeof(htmldata), NETCONN_NOCOPY);
  netbuf_delete(inbuf);
  }
  netconn_close(newconn);
  netconn_delete(newconn);
}
  }
}

网页内容：
const unsigned char htmldata[]={
"HTTP/1.1 200 OK\r\n"
"Date: Sat, 4 Apr 2015 18:54:17 GMT\r\n"
"Server: microHttp/1.0 Zlgmcu Corporation\r\n"
"Accept-Ranges: bytes\r\n"
"Connection: Keep-Close\r\n"
"Content-Type: text/html; charset=gb2312\r\n"
"\r\n"
"<HTML>\r\n"
  "<HEAD>\r\n"
  "<TITLE>this is Lwip test</TITLE>\r\n"
  "<BODY>\r\n"
  "<H1>HELLO WELCOME TO LWIP WEB sever</H1>\r\n"
"<P>硬件平台：ARM</P>\r\n"
"<P>软件平台：UCOS Lwip</P>\r\n"
"<P>Design by ***</P>\r\n"
"</BODY>\r\n"
"</HTML>\r\n"
};

只看该作者 · 2019-3-31 11:30

支持下，谢谢分享！

只看该作者 · 2019-3-31 14:42

不错，支持下！