LWIP带UCOS操作系统移植加入代码不能正常的切换

以下是源程序：
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "lcd.h"
#include "key.h"  
#include "dma.h"
#include "adc.h"
#include "dac.h"
#include "PG.h"
#include "24cxx.h"
#include "rtc.h"
#include "timer.h"
#include "math.h"
#include "arm_math.h"
#include "includes.h"
#include "lwip_comm.h"
#include "LAN8720.h"
#include "sram.h"
#include "malloc.h"
#include "lwipopts.h"
#define SEND_BUF_SIZE 32        //发送数据长度,最好等于sizeof(TEXT_TO_SEND)+2的整数倍.
u8 SendBuff[SEND_BUF_SIZE];        //串口发送数据缓冲区
u8 RxBuff[SEND_BUF_SIZE];        //串口接收数据缓冲区
u16 ADC_buf[3];  //ADC接收数据缓冲区
const u8 TEXT_TO_SEND[]={0x02,0x06,0x01,0x10,0x13,0x88,0x84,0x96};         
u32 DW[500];
       
/////////////////////////UCOSII任务设置///////////////////////////////////
//UART任务
//设置任务优先级
#define UART_TASK_PRIO                               14
//设置任务堆栈大小
#define UART_STK_SIZE                                          64
//任务堆栈
__align(8) OS_STK UART_TASK_STK[UART_STK_SIZE];
//任务函数
void UART_task(void *pdata);
//ADC任务
//设置任务优先级
#define ADC_TASK_PRIO                               15
//设置任务堆栈大小
#define ADC_STK_SIZE                                        128
//任务堆栈
__align(8) OS_STK ADC_TASK_STK[ADC_STK_SIZE];
//任务函数
void ADC_task(void *pdata);
//Filter任务(ADC滤波算法）
//设置任务优先级
#define Filter_TASK_PRIO                               16
//设置任务堆栈大小
#define Filter_STK_SIZE                                        256
//任务堆栈
__align(8) OS_STK Filter_TASK_STK[Filter_STK_SIZE];
//任务函数
void Filter_task(void *pdata);
//DAC任务
//设置任务优先级
#define DAC_TASK_PRIO                               17
//设置任务堆栈大小
#define DAC_STK_SIZE                                        64
//任务堆栈
__align(8) OS_STK DAC_TASK_STK[DAC_STK_SIZE];
//任务函数
void DAC_task(void *pdata);
//LED0任务
//设置任务优先级
#define LED0_TASK_PRIO                               18
//设置任务堆栈大小
#define LED0_STK_SIZE                                      128
//任务堆栈       
__align(8) OS_STK LED0_TASK_STK[LED0_STK_SIZE];
//任务函数
void led0_task(void *pdata);
//LED1任务
//设置任务优先级
#define LED1_TASK_PRIO                               19
//设置任务堆栈大小
#define LED1_STK_SIZE                                          64
//任务堆栈
__align(8) OS_STK LED1_TASK_STK[LED1_STK_SIZE];
//任务函数
void led1_task(void *pdata);
//TIME任务
//设置任务优先级
#define TIME_TASK_PRIO                               20
//设置任务堆栈大小
#define TIME_STK_SIZE                                          128
//任务堆栈
__align(8) OS_STK TIME_TASK_STK[TIME_STK_SIZE];
//任务函数
void TIME_task(void *pdata);
//AT24C任务(ADC滤波算法）
//设置任务优先级
#define AT24C_TASK_PRIO                               21
//设置任务堆栈大小
#define AT24C_STK_SIZE                                        128
//任务堆栈
__align(8) OS_STK AT24C_TASK_STK[AT24C_STK_SIZE];
//任务函数
void AT24C_task(void *pdata);
//在LCD上显示地址信息任务
//任务优先级
#define DISPLAY_TASK_PRIO                                22
//任务堆栈大小
#define DISPLAY_STK_SIZE                                128
//任务堆栈
__align(8) OS_STK        DISPLAY_TASK_STK[DISPLAY_STK_SIZE];
//任务函数
void display_task(void *pdata);
//START 任务
//设置任务优先级
#define START_TASK_PRIO                              30 //开始任务的优先级设置为最低
//设置任务堆栈大小
#define START_STK_SIZE                                  64
//任务堆栈       
__align(8) OS_STK START_TASK_STK[START_STK_SIZE];
//任务函数
void start_task(void *pdata);
int main(void)
{
        delay_init(168);                  //初始化延时函数
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
        LED_Init();                        //初始化LED端口
        LCD_Init();                                        //LCD初始化
        KEY_Init();                                 //按键初始化
        PG_Init();                                 //PG端口初始化
       
        FSMC_SRAM_Init(); //SRAM 初始化
        mymem_init(SRAMIN);          //初始化内部内存池
        mymem_init(SRAMEX);          //初始化外部内存池
        mymem_init(SRAMCCM);         //初始化CCM内存池
       
        OSInit();
       
        while(lwip_comm_init())         //lwip初始化
        {
                LCD_ShowString(30,10,200,20,16,"Lwip Init failed!");         //lwip初始化失败
                delay_ms(500);
                LCD_Fill(30,10,230,150,WHITE);
                delay_ms(500);
        }
        LCD_ShowString(30,10,200,20,16,"Lwip Init Success!");                 //lwip初始化成功
       
        OSTaskCreate(start_task,(void *)0,(OS_STK *)&START_TASK_STK[START_STK_SIZE-1],START_TASK_PRIO );//创建起始任务
       
        OSStart();       
}
void init(void)
{
        u16 i;
        u8 t=0;
        u8 j,mask=0;
//        float pro=0;//进度
//        u16 adcx;
        //float32_t *temp;
//        u32 temp1;
//        u16 dacval=0;//DAC输出值
//        u8 tbuf[40];
       
       
//        RTC_TimeTypeDef RTC_TimeStruct;//时钟时间
//        RTC_DateTypeDef RTC_DateStruct;//时钟日期
       
        NVIC_InitTypeDef NVIC_InitStructure;
//        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
       
//        delay_init(168);     //初始化延时函数
//        LED_Init();                                        //初始化LED
//         LCD_Init();                                        //LCD初始化
//        KEY_Init();                                 //按键初始化
//        PG_Init();                                 //PG端口初始化
       
       
        //delay_init(168);                  //初始化延时函数
        //LED_Init();                        //初始化LED端口
//        OSInit();   
//         OSTaskCreate(start_task,(void *)0,(OS_STK *)&START_TASK_STK[START_STK_SIZE-1],START_TASK_PRIO );//创建起始任务
//       
        //串口1和串口6最高波特率为10.5M，其他为5.25M
        //串口1设置
        uart1_init(115200);        //初始化串口1波特率为115200，引脚为PA9、PA10       
        MYDMA_USART_Config(DMA2_Stream7,DMA_Channel_4,(u32)&USART1->DR,(u32)SendBuff,SEND_BUF_SIZE,DMA2_Stream5,DMA_Channel_4,(u32)RxBuff,SEND_BUF_SIZE);//设置串口1为DMA2流5通道4接收和DMA2流7通道4发送，发送数组SendBuff，数量SEND_BUF_SIZE，接收数组RxBuff[]，数量SEND_BUF_SIZE
        USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);  //使能串口1的DMA接收，每次最多USART_REC_LEN个字
        MYDMA_Enable(DMA2_Stream5,USART_REC_LEN);
        USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE);  //使能串口1的DMA发送     
        DMA_ITConfig(DMA2_Stream7,DMA_IT_TC,ENABLE);        //使能串口1 DMA发送中断
        NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream7_IRQn;//串口1中断通道
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority =5;                //子优先级3
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
        NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
        DMA_ITConfig(DMA2_Stream5,DMA_IT_TC,ENABLE);        //使能串口1 DMA接收中断
        NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream5_IRQn;//串口1中断通道
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority =6;                //子优先级3
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
        NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
        //串口3设置
        uart3_init(115200);        //初始化串口3波特率为115200，引脚为PB10、PB11
        MYDMA_USART_Config(DMA1_Stream3,DMA_Channel_4,(u32)&USART3->DR,(u32)SendBuff,SEND_BUF_SIZE,DMA1_Stream1,DMA_Channel_4,(u32)RxBuff,SEND_BUF_SIZE);//设置串口3 DMA1流1通道4接收和DMA1流3通道4发送，接收数组RxBuff[]，数量SEND_BUF_SIZE，发送数组SendBuff[]，，数量SEND_BUF_SIZE
        USART_DMACmd(USART3,USART_DMAReq_Rx,ENABLE);  //使能串口3的DMA接收，每次最多USART_REC_LEN个字
        MYDMA_Enable(DMA1_Stream1,USART_REC_LEN);
        USART_DMACmd(USART3,USART_DMAReq_Tx,ENABLE);  //使能串口3的DMA发送   
        DMA_ITConfig(DMA1_Stream3,DMA_IT_TC,ENABLE);        //使能串口3 DMA发送中断
        NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream3_IRQn;//串口3中断通道
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority =7;                //子优先级3
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
        NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
        DMA_ITConfig(DMA1_Stream1,DMA_IT_TC,ENABLE);        //使能串口3 DMA接收中断
        NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream1_IRQn;//串口3中断通道
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority =8;                //子优先级3
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
        NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
        //串口4设置
        uart4_init(115200);        //初始化串口3波特率为115200，引脚为PC10、PC11
        MYDMA_USART_Config(DMA1_Stream4,DMA_Channel_4,(u32)&UART4->DR,(u32)SendBuff,SEND_BUF_SIZE,DMA1_Stream2,DMA_Channel_4,(u32)RxBuff,SEND_BUF_SIZE);//设置串口4 DMA1流2通道4接收和DMA1流4通道4发送
        USART_DMACmd(UART4,USART_DMAReq_Rx,ENABLE);  //使能串口4的DMA接收，每次最多USART_REC_LEN个字
        MYDMA_Enable(DMA1_Stream2,USART_REC_LEN);
        USART_DMACmd(UART4,USART_DMAReq_Tx,ENABLE);  //使能串口4的DMA发送   
        DMA_ITConfig(DMA1_Stream4,DMA_IT_TC,ENABLE);        //使能串口4 DMA发送中断
        NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream4_IRQn;//串口4中断通道
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority =7;                //子优先级3
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
        NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
        DMA_ITConfig(DMA1_Stream2,DMA_IT_TC,ENABLE);        //使能串口4 DMA接收中断
        NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream2_IRQn;//串口4中断通道
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority =8;                //子优先级3
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
        NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
        //串口6设置
        uart6_init(115200);        //初始化串口6波特率为115200，引脚为PC6、PC7
        MYDMA_USART_Config(DMA2_Stream6,DMA_Channel_5,(u32)&USART6->DR,(u32)SendBuff,SEND_BUF_SIZE,DMA2_Stream1,DMA_Channel_5,(u32)RxBuff,SEND_BUF_SIZE);//设置串口6 DMA2流1通道5接收和DMA2流6通道5发送
        USART_DMACmd(USART6,USART_DMAReq_Rx,ENABLE);  //使能串口6的DMA接收，每次最多USART_REC_LEN个字
        MYDMA_Enable(DMA2_Stream1,USART_REC_LEN);
        USART_DMACmd(USART6,USART_DMAReq_Tx,ENABLE);  //使能串口6的DMA发送   
        DMA_ITConfig(DMA2_Stream6,DMA_IT_TC,ENABLE);        //使能串口6 DMA发送中断
        NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream6_IRQn;//串口1中断通道
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority =5;                //子优先级3
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
        NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
        DMA_ITConfig(DMA2_Stream1,DMA_IT_TC,ENABLE);        //使能串口6 DMA接收中断
        NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream1_IRQn;//串口1中断通道
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority =6;                //子优先级3
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
        NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
       
        //DAC初始化
        Dac1_Init();                                 //DAC通道1初始化       
       
        //ADC初始化
        Adc_Init();                                 //adc初始化
        ADC_DMA_Config(DMA2_Stream4,DMA_Channel_0,(u32)&ADC1->DR,(u32)ADC_buf);
        ADC_SoftwareStartConv(ADC1); //如果不是外部触发则必须软件开始转换
       
        //初始化EEPROM
        AT24CXX_Init();
       
        //初始化RTC
        My_RTC_Init();                                
        //RTC_Set_WakeUp(RTC_WakeUpClock_CK_SPRE_16bits,0);                //配置WAKE UP中断,1秒钟中断一次
       
        //初始化定时器
//        TIM2_Int_Init(1000-1,8400-1);        //定时器时钟84M，分频系数8400，所以84M/8400=10Khz的计数频率，计数1000次为100ms
//        TIM3_Int_Init(10000-1,8400-1);        //定时器时钟84M，分频系数8400，所以84M/8400=10Khz的计数频率，计数1000次为1s
       
        POINT_COLOR=RED;        
        LCD_ShowString(30,130,200,16,16,"KEY0:Start");         
        POINT_COLOR=BLUE;//设置字体为蓝色               
//        LCD_ShowString(30,400,200,16,16,"DAC VAL:");             
//        LCD_ShowString(30,420,200,16,16,"DAC VOL:0.000V");             
//        LCD_ShowString(30,450,200,16,16,"ADC VOL:0.000V");
//
//sqrt(2);//不使用FPU计算2的平方根
//        arm_sqrt_f32(2,temp);//使用FPU计算2的平方根
//        temp1=(u32)(*temp*1000);//浮点数强制转换为整数
//显示提示信息       
        j=sizeof(TEXT_TO_SEND);          
        for(i=0;i     {
                if(t>=j)//加入换行符
                {
                        if(mask)
                        {
                                SendBuff=0x0a;
                                t=0;
                        }else
                        {
                                SendBuff=0x0d;
                                mask++;
                        }       
                }else//复制TEXT_TO_SEND语句
                {
                        mask=0;
                        SendBuff=TEXT_TO_SEND[t];
                        t++;
                }             
    }
}
//在LCD上显示地址信息
//mode:1 显示DHCP获取到的地址
//          其他 显示静态地址
void show_address(u8 mode)
{
        u8 buf[30];
        if(mode==2)
        {
                //sprintf((char*)buf,"DHCP IP :%d.%d.%d.%d",lwipdev.ip[0],lwipdev.ip[1],lwipdev.ip[2],lwipdev.ip[3]);                                                //打印动态IP地址
                LCD_ShowString(30,470,210,16,16,buf);
                //sprintf((char*)buf,"DHCP GW :%d.%d.%d.%d",lwipdev.gateway[0],lwipdev.gateway[1],lwipdev.gateway[2],lwipdev.gateway[3]);        //打印网关地址
                LCD_ShowString(30,490,210,16,16,buf);
                //sprintf((char*)buf,"NET MASK:%d.%d.%d.%d",lwipdev.netmask[0],lwipdev.netmask[1],lwipdev.netmask[2],lwipdev.netmask[3]);        //打印子网掩码地址
                LCD_ShowString(30,510,210,16,16,buf);
        }
        else
        {
                //sprintf((char*)buf,"Static IP:%d.%d.%d.%d",lwipdev.ip[0],lwipdev.ip[1],lwipdev.ip[2],lwipdev.ip[3]);                                                //打印动态IP地址
                LCD_ShowString(30,470,210,16,16,buf);
                //sprintf((char*)buf,"Static GW:%d.%d.%d.%d",lwipdev.gateway[0],lwipdev.gateway[1],lwipdev.gateway[2],lwipdev.gateway[3]);        //打印网关地址
                LCD_ShowString(30,490,210,16,16,buf);
                //sprintf((char*)buf,"NET MASK :%d.%d.%d.%d",lwipdev.netmask[0],lwipdev.netmask[1],lwipdev.netmask[2],lwipdev.netmask[3]);        //打印子网掩码地址
                LCD_ShowString(30,510,210,16,16,buf);
        }       
}
//开始任务
void start_task(void *pdata)
{
        OS_CPU_SR cpu_sr=0;
        pdata = pdata;
        init();
          OS_ENTER_CRITICAL();                        //进入临界区(无法被中断打断)
#if LWIP_DHCP
        lwip_comm_dhcp_creat(); //创建DHCP任务
#endif
       
        OSTaskCreate(UART_task,(void *)0,(OS_STK*)&UART_TASK_STK[UART_STK_SIZE-1],UART_TASK_PRIO);       
        OSTaskCreate(ADC_task,(void *)0,(OS_STK*)&ADC_TASK_STK[ADC_STK_SIZE-1],ADC_TASK_PRIO);       
        OSTaskCreate(Filter_task,(void *)0,(OS_STK*)&Filter_TASK_STK[Filter_STK_SIZE-1],Filter_TASK_PRIO);       
        OSTaskCreate(DAC_task,(void *)0,(OS_STK*)&DAC_TASK_STK[DAC_STK_SIZE-1],DAC_TASK_PRIO);       
        OSTaskCreate(led0_task,(void *)0,(OS_STK*)&LED0_TASK_STK[LED0_STK_SIZE-1],LED0_TASK_PRIO);                                                  
        OSTaskCreate(display_task,(void*)0,(OS_STK*)&DISPLAY_TASK_STK[DISPLAY_STK_SIZE-1],DISPLAY_TASK_PRIO); //显示任务
        OSTaskCreate(TIME_task,(void *)0,(OS_STK*)&TIME_TASK_STK[TIME_STK_SIZE-1],TIME_TASK_PRIO);       
        OSTaskCreate(led1_task,(void *)0,(OS_STK*)&LED1_TASK_STK[LED1_STK_SIZE-1],LED1_TASK_PRIO);       
        OSTaskCreate(AT24C_task,(void *)0,(OS_STK*)&AT24C_TASK_STK[AT24C_STK_SIZE-1],AT24C_TASK_PRIO);       
       
        OSTaskSuspend(START_TASK_PRIO);        //挂起起始任务.
        OS_EXIT_CRITICAL();                                //退出临界区(可以被中断打断)
}
//UART任务
void UART_task(void *pdata)
{          
        pdata=pdata;
        while(1)
        {
                MYDMA_Enable(DMA2_Stream7,8);     //U1开始一次DMA传输
                LCD_ShowNum(30,190,RxBuff[0],3,16);
                LCD_ShowNum(30,210,RxBuff[1],3,16);
                LCD_ShowNum(30,230,RxBuff[2],3,16);
                LCD_ShowNum(30,250,RxBuff[3],3,16);
                LCD_ShowNum(30,280,RxBuff[4],3,16);
                LCD_ShowNum(30,310,RxBuff[5],3,16);
                LCD_ShowNum(30,330,RxBuff[6],3,16);
                LCD_ShowNum(30,350,RxBuff[7],3,16);
                //delay_ms(10);
                OSTimeDlyHMSM(0,0,0,10);
        };
}
//ADC任务
void ADC_task(void *pdata)
{                
        pdata=pdata;
        while(1)
        {
                //以PA0、PA3、PA6作为ADC1通道0、通道3、通道6输入，开启DMA传输
                LCD_ShowNum(30,370,ADC_buf[0],4,16);//PA0
                LCD_ShowNum(30,390,ADC_buf[1],4,16);//PA3
                LCD_ShowNum(30,410,ADC_buf[2],4,16);//PA6
                OSTimeDlyHMSM(0,0,0,50);
                //delay_ms(50);
        };
}
//Filter任务
//将取样值从大到小排列，下次用取样值代替最大和最小值
void Filter_task(void *pdata)
{                
        int i, j;
        int filter_buf[10];//ADC取样
        int filter_temp;//, filter_sum = 0;
        pdata=pdata;
        while(1)
        {
                filter_buf[0] = ADC_buf[0];
                OSTimeDlyHMSM(0,0,0,50);
                //delay_ms(50);
                filter_buf[9] = ADC_buf[0];
                // 采样值从小到大排列（冒泡法）
                for(j = 0; j < 10 - 1; j++)
                {
                        for(i = 0; i < 10 - 1 - j; i++)
                        {
                                if(filter_buf > filter_buf[i + 1])
                                {
                                        filter_temp = filter_buf;
                                        filter_buf = filter_buf[i + 1];
                                        filter_buf[i + 1] = filter_temp;
                                }
                        }
                }
                LCD_ShowNum(30,440,filter_buf[5],4,16);//PA0
                OSTimeDlyHMSM(0,0,0,50);
                //delay_ms(50);
        }
}
//DAC任务
void DAC_task(void *pdata)
{                
        u16 i;
        pdata=pdata;
        while(1)
        {
                Dac1_Set_Vol(i);
                if (i<3300)
                i=i+50;
                else
                i=0;
                OSTimeDlyHMSM(0,0,0,500);
                //delay_ms(500);
        };
}
//LED0任务
void led0_task(void *pdata)
{                
        u32 temp1;
        float32_t *temp;
        pdata=pdata;
        while(1)
        {
//                arm_sqrt_f32(2,temp);//使用FPU计算2的平方根
//                temp1=(u32)(*temp*1000);//浮点数强制转换为整数
                //temp1=__sqrtf(3.0f)*1000;
                LCD_ShowxNum(110,600,temp1,4,16,0X80);
               
//#if LWIP_DHCP                                                                        //当开启DHCP的时候
//                if(lwipdev.dhcpstatus != 0)                         //开启DHCP
//                {
//                        show_address(lwipdev.dhcpstatus );        //显示地址信息
//                        OSTaskSuspend(OS_PRIO_SELF);                 //显示完地址信息后挂起自身任务
//                }
//#else
//                show_address(0);                                                 //显示静态地址
//                OSTaskSuspend(OS_PRIO_SELF);                         //显示完地址信息后挂起自身任务
//#endif //LWIP_DHCP
//                LED0=0;
//                delay_ms(80);
//                LED0=1;
                OSTimeDlyHMSM(0,0,0,920);
                //delay_ms(920);
        };
}
//LED1任务
void led1_task(void *pdata)
{          
        pdata=pdata;
        while(1)
        {
                LED1=0;
                OSTimeDlyHMSM(0,0,0,300);
                //delay_ms(300);
                LED1=1;
                OSTimeDlyHMSM(0,0,0,300);
                //delay_ms(300);
        };
}
//TIME任务
void TIME_task(void *pdata)
{                
        RTC_TimeTypeDef RTC_TimeStruct;//时钟时间
        RTC_DateTypeDef RTC_DateStruct;//时钟日期
        u8 tbuf[40];
        pdata=pdata;
        while(1)
        {
                RTC_GetTime(RTC_Format_BIN,&RTC_TimeStruct);
                RTC_GetDate(RTC_Format_BIN, &RTC_DateStruct);
                //RTC_TimeStruct.RTC_Hours,RTC_TimeStruct.RTC_Minutes,RTC_TimeStruct.RTC_Seconds,RTC_DateStruct.RTC_Year,RTC_DateStruct.RTC_Month,RTC_DateStruct.RTC_Date
                sprintf((char*)tbuf,"Time:%02d:%02d:%02d",RTC_TimeStruct.RTC_Hours,RTC_TimeStruct.RTC_Minutes,RTC_TimeStruct.RTC_Seconds);
                LCD_ShowString(30,140,210,16,16,tbuf);        //LCD 显示函数占用CPU资源很大
                OSTimeDlyHMSM(0,0,1,0);
                //delay_ms(1000);
        };
}
//AT24C任务
void AT24C_task(void *pdata)
{                
        int i=0;
        pdata=pdata;
        for (i=0;i<64;i++)
        {
                DW=AT24CXX_ReadLenByte(i*4,4);
        }
        while(1)
        {
                //i++;
                //AT24CXX_WriteLenByte(4,i,4);
                LCD_ShowNum(30,460,AT24CXX_ReadLenByte(4,4),4,16);
                OSTimeDlyHMSM(0,0,2,0);
                //delay_ms(2000);
        };
}
//显示地址等信息
void display_task(void *pdata)
{
        pdata=pdata;
        while(1)
        {
                LED0=!LED0;
//#if LWIP_DHCP                                                                        //当开启DHCP的时候
//                if(lwipdev.dhcpstatus != 0)                         //开启DHCP
//                {
//                        show_address(lwipdev.dhcpstatus );        //显示地址信息
//                        OSTaskSuspend(OS_PRIO_SELF);                 //显示完地址信息后挂起自身任务
//                }
//#else
//                show_address(0);                                                 //显示静态地址
//                OSTaskSuspend(OS_PRIO_SELF);                         //显示完地址信息后挂起自身任务
//#endif //LWIP_DHCP
                OSTimeDlyHMSM(0,0,1,0);
                //delay_ms(1000);
        }
}

即使修改后面不运行任务的优先级也没用，反正按排列顺序最后三个不运行。

因为前面的任务优先级高，占用的时候太短的话，没有时间来执行最后面的任务，你可以把前面任务的时间都设置长点，再试试。

已解决，是配置的任务数量不够的原因