Ai8051U学习打卡

MJ***

今日使昨天买的 TFT屏 运行 DEMO 72.1节72.1-UART-SPI-TFT_DMA_P2P外设到外设_显示图片程序，不知道为什么 图片取模工工具转化的文件通过CDC/HID串口助手传输的时候，都是红色的字，传输完成后屏幕也不显示，还得抽时间多研究研究。

MJ***

今天仔细学了《AI8051U深度入门》的第七集 定时器中断

使用示例代码加了点细节，实现按下P32松手后，P01才开始点亮3秒
#include <AI8051U.H>                //包含AI8051U的头文件
#include "intrins.h"                //使用_nop_()函数所必须要包含的头文件,
                                    //否则延时函数中调用的_nop_()函数没有被头文件引用过来，
                                    //会导致编译器找不到这个而函数而报错。
#include "stc32_stc8_usb.h"                                        //不断电下载头文件

//char *USER_DEVICEDESC = NULL;
//char *USER_PRODUCTDESC = NULL;
//char *USER_STCISPCMD ="@STCISP#";
u8 state=0;
u8 temp=0;
void Delay20us(void)        //@24.000MHz
{
        unsigned long edata i;

        _nop_();
        _nop_();
        _nop_();
        i = 118UL;
        while (i) i--;
}

void Delay500ms(void)        //@24.000MHz
{
        unsigned long edata i;

        _nop_();
        _nop_();
        i = 2999998UL;
        while (i) i--;
}

                                    //上面延时函数部分代码可使用AIapp-ISP软件的“软件延时计算器”工具来生成。
void Timer0_Init(void)                //3秒@24.000MHz
{
        TM0PS = 0x5B;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        //5B=91
        AUXR &= 0x7F;                        //定时器时钟12T模式 &=0x7F 就是&=01111111余等于就是最高位清零
        TMOD &= 0xF0;                        //设置定时器模式 低四位置零
        TL0 = 0x3F;                                //设置定时初始值
        TH0 = 0x01;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
        ET0 = 1;                                //使能定时器0中断
}

void main(void)
{
       

       
    EAXFR = 1;                      //允许访问扩展的特殊寄存器，XFR
                                    //(32 位模式请使用这句，注释下一句)
   // P_SW2 |= 0x80;                  //允许访问扩展的特殊寄存器，XFR
                                    //(8位模式请使用这句，注释上一句)。
    WTST = 0;                       //设置取程序代码等待时间，
                                    //赋值为 0表示不等待，程序以最快速度运行
    CKCON = 0;                      //设置访问片内的 xdata速度，
                                    //赋值为 0表示用最快速度访问，不增加额外的等待时间
                                    
    P0M0 = 0x00; P0M1 = 0x00;       //设置P0口为准双向口模式
    P1M0 = 0x00; P1M1 = 0x00;       //设置P1口为准双向口模式
    P2M0 = 0x00; P2M1 = 0x00;       //设置P2口为准双向口模式
    P3M0 = 0x00; P3M1 = 0x00;       //设置P3口为准双向口模式
    P4M0 = 0x00; P4M1 = 0x00;       //设置P4口为准双向口模式
    P5M0 = 0x00; P5M1 = 0x00;       //设置P5口为准双向口模式
    P6M0 = 0x00; P6M1 = 0x00;       //设置P6口为准双向口模式
    P7M0 = 0x00; P7M1 = 0x00;       //设置P7口为准双向口模式
                                    //上面的将所有I/O口都初始化为准双向口工作模式的程序，
                                    //可以使用AIapp-ISP软件的“I/O口配置工具”来生成。
    usb_init();                     //USB CDC 接口配置
        IE2 |=0x80;                                                //使能USB中断                                                               
       
        EA = 1;
    P40 = 0;                        //打开LED部分的供电
       
        while (DeviceState != DEVSTATE_CONFIGURED);//等待USB完成配置
    while(1)                        
    {   
                if (bUsbOutReady)
        {
           // USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
            usb_OUT_done();
        }

                //任务2 按下按键灯亮3秒
                if(P32==0)
                {
                        Delay20us();
                        if(P32==0)
                        {
                        while(P32==0);   //等P32松开
                                P01=0;
                                Timer0_Init();
                }
    }
}
}

void Timer0_Isr(void) interrupt 1  //3秒执行一次 在初始化配置好了
{
       
        P01=1;
        TR0 = 0;                                //定时器0关闭计时
}

MJ***

《AI8051U深度入门》第七课里任务3 救护车灯的实验中，我学习到怎样按下P32键使得P00和P01交替闪烁，又觉得每次只亮一个led灯不够显眼，于是变成每次亮两个灯，但是又发现，每次按下P32，P00或P01谁先亮，取决于在那个灯亮的时候按下p32熄灭灯，我想让每次按下P32 都是固定的LED开始亮，所以在关闭定时器和关闭led的那半截else语句里，又增加了state=0;从实验箱上运行后观察到，不论在那个LED灯亮的时候按下P32熄灭led，再次按下p32的时候每次都是从P01开始点亮。

#include <AI8051U.H>                //包含AI8051U的头文件
#include "intrins.h"                //使用_nop_()函数所必须要包含的头文件,
                                    //否则延时函数中调用的_nop_()函数没有被头文件引用过来，
                                    //会导致编译器找不到这个而函数而报错。
#include "stc32_stc8_usb.h"                                        //不断电下载头文件

//char *USER_DEVICEDESC = NULL;
//char *USER_PRODUCTDESC = NULL;
//char *USER_STCISPCMD ="@STCISP#";

u8 state=0;                                                //初始状态
u8 Run_State=0;                                        //运行状态

void Delay20us(void)        //@24.000MHz
{
        unsigned long edata i;

        _nop_();
        _nop_();
        _nop_();
        i = 118UL;
        while (i) i--;
}

void Delay500ms(void)        //@24.000MHz
{
        unsigned long edata i;

        _nop_();
        _nop_();
        i = 2999998UL;
        while (i) i--;
}

                                    //上面延时函数部分代码可使用AIapp-ISP软件的“软件延时计算器”工具来生成。
void Timer0_Init(void)                //500毫秒@24.000MHz
{
        TM0PS = 0x0F;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0xDC;                                //设置定时初始值
        TH0 = 0x0B;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
        ET0 = 1;                                //使能定时器0中断
}


void main(void)
{
       

       
    EAXFR = 1;                      //允许访问扩展的特殊寄存器，XFR
                                    //(32 位模式请使用这句，注释下一句)
   // P_SW2 |= 0x80;                  //允许访问扩展的特殊寄存器，XFR
                                    //(8位模式请使用这句，注释上一句)。
    WTST = 0;                       //设置取程序代码等待时间，
                                    //赋值为 0表示不等待，程序以最快速度运行
    CKCON = 0;                      //设置访问片内的 xdata速度，
                                    //赋值为 0表示用最快速度访问，不增加额外的等待时间
                                    
    P0M0 = 0x00; P0M1 = 0x00;       //设置P0口为准双向口模式
    P1M0 = 0x00; P1M1 = 0x00;       //设置P1口为准双向口模式
    P2M0 = 0x00; P2M1 = 0x00;       //设置P2口为准双向口模式
    P3M0 = 0x00; P3M1 = 0x00;       //设置P3口为准双向口模式
    P4M0 = 0x00; P4M1 = 0x00;       //设置P4口为准双向口模式
    P5M0 = 0x00; P5M1 = 0x00;       //设置P5口为准双向口模式
    P6M0 = 0x00; P6M1 = 0x00;       //设置P6口为准双向口模式
    P7M0 = 0x00; P7M1 = 0x00;       //设置P7口为准双向口模式
                                    //上面的将所有I/O口都初始化为准双向口工作模式的程序，
                                    //可以使用AIapp-ISP软件的“I/O口配置工具”来生成。
    usb_init();                     //USB CDC 接口配置
        IE2 |=0x80;                                                //使能USB中断                                                               
       
        EA = 1;
    P40 = 0;                        //打开LED部分的供电
       
        while (DeviceState != DEVSTATE_CONFIGURED);//等待USB完成配置
    while(1)                        
    {   
                if (bUsbOutReady)
        {
           // USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
            usb_OUT_done();
        }

                //任务3 按下按键灯亮LED交替闪烁 再按下就停
                if(P32==0)
                {
                        Delay20us();
                        if(P32==0)
                        {
                        while(P32==0);                                   //等P32松开
                                Run_State =!Run_State;                 //运行状态取反
                                if(Run_State==1)
                                {
                                        Timer0_Init();
                                }
                                else
                                {
                                        TR0=0;    //关闭定时器
                                        P00=1;
                                        P01=1;
                                        P02=1;
                                        P03=1;
                                        state=0;   //每次按下P32都是从P01开始亮
                                }
                }
    }
}
}

void Timer0_Isr(void) interrupt 1  //3秒执行一次 在初始化配置好了
{
       
        state=!state;
        P00=state;
        P01=!state;
        P02=state;
        P03=!state;
       
}

MJ***

今天根据《AI8051U》深度入门视频第7集课后思考题 功德+1和功德+2的提示，使用闪烁时长500ms和1s代表功德+1和功德+2，使用if else语句对两个时长的定时器进行切换

#include <AI8051U.H>                //包含AI8051U的头文件
#include "intrins.h"                //使用_nop_()函数所必须要包含的头文件,
                                    //否则延时函数中调用的_nop_()函数没有被头文件引用过来，
                                    //会导致编译器找不到这个而函数而报错。
#include "stc32_stc8_usb.h"                                        //不断电下载头文件

//char *USER_DEVICEDESC = NULL;
//char *USER_PRODUCTDESC = NULL;
//char *USER_STCISPCMD ="@STCISP#";

u8 state=0;                                                //初始状态
u8 Run_State=0;                                        //运行状态

void Delay20us(void)        //@24.000MHz
{
        unsigned long edata i;

        _nop_();
        _nop_();
        _nop_();
        i = 118UL;
        while (i) i--;
}

void Delay500ms(void)        //@24.000MHz
{
        unsigned long edata i;

        _nop_();
        _nop_();
        i = 2999998UL;
        while (i) i--;
}

                                    //上面延时函数部分代码可使用AIapp-ISP软件的“软件延时计算器”工具来生成。
void Timer0_Init500ms(void)                //500毫秒@24.000MHz
{
        TM0PS = 0x0F;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0xDC;                                //设置定时初始值
        TH0 = 0x0B;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
        ET0 = 1;                                //使能定时器0中断
}

void Timer0_Init(void)                //1秒@24.000MHz
{
        TM0PS = 0x1E;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0xFC;                                //设置定时初始值
        TH0 = 0x03;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
        ET0 = 1;                                //使能定时器0中断
}




void main(void)
{
       

       
    EAXFR = 1;                      //允许访问扩展的特殊寄存器，XFR
                                    //(32 位模式请使用这句，注释下一句)
   // P_SW2 |= 0x80;                  //允许访问扩展的特殊寄存器，XFR
                                    //(8位模式请使用这句，注释上一句)。
    WTST = 0;                       //设置取程序代码等待时间，
                                    //赋值为 0表示不等待，程序以最快速度运行
    CKCON = 0;                      //设置访问片内的 xdata速度，
                                    //赋值为 0表示用最快速度访问，不增加额外的等待时间
                                    
    P0M0 = 0x00; P0M1 = 0x00;       //设置P0口为准双向口模式
    P1M0 = 0x00; P1M1 = 0x00;       //设置P1口为准双向口模式
    P2M0 = 0x00; P2M1 = 0x00;       //设置P2口为准双向口模式
    P3M0 = 0x00; P3M1 = 0x00;       //设置P3口为准双向口模式
    P4M0 = 0x00; P4M1 = 0x00;       //设置P4口为准双向口模式
    P5M0 = 0x00; P5M1 = 0x00;       //设置P5口为准双向口模式
    P6M0 = 0x00; P6M1 = 0x00;       //设置P6口为准双向口模式
    P7M0 = 0x00; P7M1 = 0x00;       //设置P7口为准双向口模式
                                    //上面的将所有I/O口都初始化为准双向口工作模式的程序，
                                    //可以使用AIapp-ISP软件的“I/O口配置工具”来生成。
    usb_init();                     //USB CDC 接口配置
        IE2 |=0x80;                                                //使能USB中断                                                               
       
        EA = 1;
    P40 = 0;                        //打开LED部分的供电
       
        while (DeviceState != DEVSTATE_CONFIGURED);//等待USB完成配置
    while(1)                        
    {   
                if (bUsbOutReady)
        {
           // USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
            usb_OUT_done();
        }

                //任务3 按下按键灯亮LED交替闪烁 再按下就停
                if(P32==0)
                {
                        Delay20us();
                        if(P32==0)
                        {
                        while(P32==0);                                   //等P32松开
                                Run_State =!Run_State;                 //运行状态取反
                                if(Run_State==1)
                                {
                                        Timer0_Init500ms();
                                       
                                }
                                else
                                {
                                        Timer0_Init();
                                }       
                }
    }
//        TR0=0;    //关闭定时器
//                                        P00=1;
//                                        P01=1;
//                                        P02=1;
//                                        P03=1;
//                                        state=0;   //每次按下P32都是从P01开始亮       
}
}

void Timer0_Isr(void) interrupt 1  //3秒执行一次 在初始化配置好了
{
       
        state=!state;
        P00=state;
        P01=!state;
        P02=state;
        P03=!state;
       
}

MJ***

今天学习了 《AI8051U》深度入门视频第8节
复现了周期性任务1 用一个定时器实现 LED1 0.3s取反，LED2 0.6s取反 LED3 0.9s取反
#include <AI8051U.H>                //包含AI8051U的头文件
#include "intrins.h"                //使用_nop_()函数所必须要包含的头文件,
                                    //否则延时函数中调用的_nop_()函数没有被头文件引用过来，
                                    //会导致编译器找不到这个而函数而报错。
#include "stc32_stc8_usb.h"                                        //不断电下载头文件

//char *USER_DEVICEDESC = NULL;
//char *USER_PRODUCTDESC = NULL;
//char *USER_STCISPCMD ="@STCISP#";

u8 State1=0;                                                //初始状态 u8是0-255 LED1初始状态
u8 State2=0;                                                //初始状态 u8是0-255 LED2初始状态
u8 State3=0;                                                //初始状态 u8是0-255 LED3初始状态
//u8 Run_State=0;                                        //运行状态
u16 Count_300 =0;                                //计数300ms
u16 Count_600 =0;                                //计数600ms
u16 Count_900 =0;                                //计数900ms

                                    //上面延时函数部分代码可使用AIapp-ISP软件的“软件延时计算器”工具来生成。
void Timer0_Init(void)                //1毫秒@24.000MHz
{
        TM0PS = 0x00;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0x30;                                //设置定时初始值
        TH0 = 0xF8;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
        ET0 = 1;                                //使能定时器0中断
}





void main(void)
{
       

       
    EAXFR = 1;                      //允许访问扩展的特殊寄存器，XFR
                                    //(32 位模式请使用这句，注释下一句)
   // P_SW2 |= 0x80;                  //允许访问扩展的特殊寄存器，XFR
                                    //(8位模式请使用这句，注释上一句)。
    WTST = 0;                       //设置取程序代码等待时间，
                                    //赋值为 0表示不等待，程序以最快速度运行
    CKCON = 0;                      //设置访问片内的 xdata速度，
                                    //赋值为 0表示用最快速度访问，不增加额外的等待时间
                                    
    P0M0 = 0x00; P0M1 = 0x00;       //设置P0口为准双向口模式
    P1M0 = 0x00; P1M1 = 0x00;       //设置P1口为准双向口模式
    P2M0 = 0x00; P2M1 = 0x00;       //设置P2口为准双向口模式
    P3M0 = 0x00; P3M1 = 0x00;       //设置P3口为准双向口模式
    P4M0 = 0x00; P4M1 = 0x00;       //设置P4口为准双向口模式
    P5M0 = 0x00; P5M1 = 0x00;       //设置P5口为准双向口模式
    P6M0 = 0x00; P6M1 = 0x00;       //设置P6口为准双向口模式
    P7M0 = 0x00; P7M1 = 0x00;       //设置P7口为准双向口模式
                                    //上面的将所有I/O口都初始化为准双向口工作模式的程序，
                                    //可以使用AIapp-ISP软件的“I/O口配置工具”来生成。
    usb_init();                     //USB CDC 接口配置
        IE2 |=0x80;                                                //使能USB中断                                                               
        Timer0_Init();
        EA = 1;
    P40 = 0;                        //打开LED部分的供电
       
        while (DeviceState != DEVSTATE_CONFIGURED);//等待USB完成配置
    while(1)                        
    {   
                if (bUsbOutReady)
        {
           // USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
            usb_OUT_done();
        }
                //周期性任务 任务1
                        //通过变量计数，使得LED1 0.3s取反，LED2 0.6s取反，LED3 0.9s取反
                if(Count_300 >=300)                        //300ms到达
                {
                        Count_300=0;                        //LED1取反       
                        State1=!State1;
                        P00=State1;
                }
                if(Count_600 >=600)                        //600ms到达
                {
                        Count_600=0;                        //LED2取反       
                        State2=!State2;
                        P01=State2;
                }
                if(Count_900 >=900)                        //900ms到达
                {
                        Count_900=0;                        //LED3取反       
                        State3=!State3;
                        P02=State3;
                }
               
                //定时器1ms增加1次
                       
}
}

void Timer0_Isr(void) interrupt 1  //1毫秒执行一次 在初始化配置好了
{
         Count_300++;                               
         Count_600++;                               
         Count_900++;
}

MJ***

今天学习《AI8051U》深度入门第8集，用数组的方式实现周期性任务

#include <AI8051U.H>                //包含AI8051U的头文件
#include "intrins.h"                //使用_nop_()函数所必须要包含的头文件,
                                    //否则延时函数中调用的_nop_()函数没有被头文件引用过来，
                                    //会导致编译器找不到这个而函数而报错。
#include "stc32_stc8_usb.h"                                        //不断电下载头文件

//char *USER_DEVICEDESC = NULL;
//char *USER_PRODUCTDESC = NULL;
//char *USER_STCISPCMD ="@STCISP#";

u8 State1=0;                                                //初始状态 u8是0-255 LED1初始状态
u8 State2=0;                                                //初始状态 u8是0-255 LED2初始状态
u8 State3=0;                                                //初始状态 u8是0-255 LED3初始状态
//u8 Run_State=0;                                        //运行状态
//u16 Count_300 =0;                                //计数300ms
//u16 Count_600 =0;                                //计数600ms
//u16 Count_900 =0;                                //计数900ms

u8 State[10]={1,2,3,4,5,6,7,8,9,10}; //建立一个数组
//Steate[0] 可以读数组
//State[0]=2 写入数组
u16 Count_ms[3]={0,0,0};    //三个计时器变量
u8 i;
                                    //上面延时函数部分代码可使用AIapp-ISP软件的“软件延时计算器”工具来生成。
void Timer0_Init(void)                //1毫秒@24.000MHz
{
        TM0PS = 0x00;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0x30;                                //设置定时初始值
        TH0 = 0xF8;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
        ET0 = 1;                                //使能定时器0中断
}





void main(void)
{
       

       
    EAXFR = 1;                      //允许访问扩展的特殊寄存器，XFR
                                    //(32 位模式请使用这句，注释下一句)
   // P_SW2 |= 0x80;                  //允许访问扩展的特殊寄存器，XFR
                                    //(8位模式请使用这句，注释上一句)。
    WTST = 0;                       //设置取程序代码等待时间，
                                    //赋值为 0表示不等待，程序以最快速度运行
    CKCON = 0;                      //设置访问片内的 xdata速度，
                                    //赋值为 0表示用最快速度访问，不增加额外的等待时间
                                    
    P0M0 = 0x00; P0M1 = 0x00;       //设置P0口为准双向口模式
    P1M0 = 0x00; P1M1 = 0x00;       //设置P1口为准双向口模式
    P2M0 = 0x00; P2M1 = 0x00;       //设置P2口为准双向口模式
    P3M0 = 0x00; P3M1 = 0x00;       //设置P3口为准双向口模式
    P4M0 = 0x00; P4M1 = 0x00;       //设置P4口为准双向口模式
    P5M0 = 0x00; P5M1 = 0x00;       //设置P5口为准双向口模式
    P6M0 = 0x00; P6M1 = 0x00;       //设置P6口为准双向口模式
    P7M0 = 0x00; P7M1 = 0x00;       //设置P7口为准双向口模式
                                    //上面的将所有I/O口都初始化为准双向口工作模式的程序，
                                    //可以使用AIapp-ISP软件的“I/O口配置工具”来生成。
    usb_init();                     //USB CDC 接口配置
        IE2 |=0x80;                                                //使能USB中断                                                               
        Timer0_Init();
        EA = 1;
    P40 = 0;                        //打开LED部分的供电
       
        while (DeviceState != DEVSTATE_CONFIGURED);//等待USB完成配置
    while(1)                        
    {   
                if (bUsbOutReady)
        {
           // USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
            usb_OUT_done();
        }
                for (i=0;i<3;i++)
                {
                        //周期性任务 任务1
                        //通过变量计数，使得LED1 0.3s取反，LED2 0.6s取反，LED3 0.9s取反
                if(Count_ms[0] >=300)                        //300ms到达
                {
                        Count_ms[0]=0;                        //LED1取反       
                        State1=!State1;
                        P00=State1;
                }
                if(Count_ms[1] >=600)                        //600ms到达
                {
                        Count_ms[1]=0;                        //LED2取反       
                        State2=!State2;
                        P01=State2;
                }
                if(Count_ms[2] >=900)                        //900ms到达
                {
                        Count_ms[2]=0;                        //LED3取反       
                        State3=!State3;
                        P02=State3;
                }
                }
               
               
               
                //定时器1ms增加1次
                       
}
}

void Timer0_Isr(void) interrupt 1  //1毫秒执行一次 在初始化配置好了
{
       
        for(i=0;i<3;i++)
        {
           Count_ms[i] ++;
        }
}

MJ***

今日复现了第8节课第二个任务流水灯，好像是头文件里有#define u8 和u16，我看本来我程序里没有，好像可以正常运行，我看到视频中的程序里有define u8 u16 就手打了一个，结果因为u16定义为char，导致led灯成了闪烁的加法器，修改程序之后，我还用数组的形式做了花式流水灯，
/*  
任务2
   低LED0                  高LDE7
   
   8  4  2  1  8  4  2  1
   B0 B1 B2 B3 B4 B5 B6 B7
   0  1  1  1  1  1  1  1  
   1  0  1  1  1  1  1  1
   1  1  0  1  1  1  1  1  
   1  1  1  0  1  1  1  1  
   1  1  1  1  0  1  1  1  
   1  1  1  1  1  0  1  1
   1  1  1  1  1  1  0  1  
   1  1  1  1  1  1  1  0  

*/
#include <AI8051U.H>                //包含AI8051U的头文件
#include "intrins.h"                //使用_nop_()函数所必须要包含的头文件,
                                    //否则延时函数中调用的_nop_()函数没有被头文件引用过来，
                                    //会导致编译器找不到这个而函数而报错。
#include "stc32_stc8_usb.h"                                        //不断电下载头文件

#define u8 unsigned char  //unsigned char 0-255
#define u16 unsigned int  //unsigned int 0-65536


//char *USER_DEVICEDESC = NULL;
//char *USER_PRODUCTDESC = NULL;
//char *USER_STCISPCMD ="@STCISP#";

u8 State1=0;                                                //初始状态 u8是0-255 LED1初始状态
u8 State2=0;                                                //初始状态 u8是0-255 LED2初始状态
u8 State3=0;                                                //初始状态 u8是0-255 LED3初始状态
u8 num=0;

//u8 State[8]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80}; //建立一个数组用于单个流水灯
//u8 State[16]={0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00}; //从左向右到头再从右向左
u8 State[16]={0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00}; //从左向右到头再从右向左

//Steate[0] 可以读数组
//State[0]=2 写入数组
u16 Count_ms[3]={0,0,0};    //三个计时器变量
u8 i;
                                    //上面延时函数部分代码可使用AIapp-ISP软件的“软件延时计算器”工具来生成。
void Timer0_Init(void)                //1毫秒@24.000MHz
{
        TM0PS = 0x00;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0x30;                                //设置定时初始值
        TH0 = 0xF8;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
        ET0 = 1;                                //使能定时器0中断
}





void main(void)
{
       

       
    EAXFR = 1;                      //允许访问扩展的特殊寄存器，XFR
                                    //(32 位模式请使用这句，注释下一句)
   // P_SW2 |= 0x80;                  //允许访问扩展的特殊寄存器，XFR
                                    //(8位模式请使用这句，注释上一句)。
    WTST = 0;                       //设置取程序代码等待时间，
                                    //赋值为 0表示不等待，程序以最快速度运行
    CKCON = 0;                      //设置访问片内的 xdata速度，
                                    //赋值为 0表示用最快速度访问，不增加额外的等待时间
                                    
    P0M0 = 0x00; P0M1 = 0x00;       //设置P0口为准双向口模式
    P1M0 = 0x00; P1M1 = 0x00;       //设置P1口为准双向口模式
    P2M0 = 0x00; P2M1 = 0x00;       //设置P2口为准双向口模式
    P3M0 = 0x00; P3M1 = 0x00;       //设置P3口为准双向口模式
    P4M0 = 0x00; P4M1 = 0x00;       //设置P4口为准双向口模式
    P5M0 = 0x00; P5M1 = 0x00;       //设置P5口为准双向口模式
    P6M0 = 0x00; P6M1 = 0x00;       //设置P6口为准双向口模式
    P7M0 = 0x00; P7M1 = 0x00;       //设置P7口为准双向口模式
                                    //上面的将所有I/O口都初始化为准双向口工作模式的程序，
                                    //可以使用AIapp-ISP软件的“I/O口配置工具”来生成。
    usb_init();                     //USB CDC 接口配置
        IE2 |=0x80;                                                //使能USB中断                                                               
        Timer0_Init();
        EA = 1;
    P40 = 0;                        //打开LED部分的供电
       
        while (DeviceState != DEVSTATE_CONFIGURED);//等待USB完成配置
    while(1)                        
    {   
                if (bUsbOutReady)
        {
           // USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
            usb_OUT_done();
        }
                if(Count_ms[0]>=500)
                {
                        Count_ms[0] =0;
                        P0 = ~State[num];  //num取值0-7
                        num++;
                        if(num>16)
                                num=0;
                }
               
               
                //定时器1ms增加1次
                       
}
}

void Timer0_Isr(void) interrupt 1  //1毫秒执行一次 在初始化配置好了
{
       
        for(i=0;i<3;i++)
        {
           Count_ms[i]++;
        }
}

MJ***

今天练习了第八节课的第三个任务，
先复现了按一下p32让led灯变化一次，但是会出现按住p32不放会卡死的现象，又复现了用计数器防止按住P32不放卡死的程序还
/*  
任务3 按键1按一下，LED灯动一下 按住P32会卡死程序
   低LED0                  高LDE7
   
   8  4  2  1  8  4  2  1
   B0 B1 B2 B3 B4 B5 B6 B7
   0  1  1  1  1  1  1  1  
   1  0  1  1  1  1  1  1
   1  1  0  1  1  1  1  1  
   1  1  1  0  1  1  1  1  
   1  1  1  1  0  1  1  1  
   1  1  1  1  1  0  1  1
   1  1  1  1  1  1  0  1  
   1  1  1  1  1  1  1  0  

*/
#include <AI8051U.H>                //包含AI8051U的头文件
#include "intrins.h"                //使用_nop_()函数所必须要包含的头文件,
                                    //否则延时函数中调用的_nop_()函数没有被头文件引用过来，
                                    //会导致编译器找不到这个而函数而报错。
#include "stc32_stc8_usb.h"                                        //不断电下载头文件

#define u8 unsigned char  //unsigned char 0-255
#define u16 unsigned int  //unsigned int 0-65536


//char *USER_DEVICEDESC = NULL;
//char *USER_PRODUCTDESC = NULL;
//char *USER_STCISPCMD ="@STCISP#";

u8 State1=0;                                                //初始状态 u8是0-255 LED1初始状态
u8 State2=0;                                                //初始状态 u8是0-255 LED2初始状态
u8 State3=0;                                                //初始状态 u8是0-255 LED3初始状态
u8 num=0;

//u8 State[8]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80}; //建立一个数组用于单个流水灯
//u8 State[16]={0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00}; //从左向右到头再从右向左
u8 State[16]={0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00}; //从左向右到头再从右向左

//Steate[0] 可以读数组
//State[0]=2 写入数组
u16 Count_ms[3]={0,0,0};    //三个计时器变量
u8 i;
                                    //上面延时函数部分代码可使用AIapp-ISP软件的“软件延时计算器”工具来生成。
void Timer0_Init(void)                //1毫秒@24.000MHz
{
        TM0PS = 0x00;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0x30;                                //设置定时初始值
        TH0 = 0xF8;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
        ET0 = 1;                                //使能定时器0中断
}

void Delay10ms(void)        //@24.000MHz
{
        unsigned long edata i;

        _nop_();
        _nop_();
        _nop_();
        i = 59998UL;
        while (i) i--;
}




void main(void)
{
       

       
    EAXFR = 1;                      //允许访问扩展的特殊寄存器，XFR
                                    //(32 位模式请使用这句，注释下一句)
   // P_SW2 |= 0x80;                  //允许访问扩展的特殊寄存器，XFR
                                    //(8位模式请使用这句，注释上一句)。
    WTST = 0;                       //设置取程序代码等待时间，
                                    //赋值为 0表示不等待，程序以最快速度运行
    CKCON = 0;                      //设置访问片内的 xdata速度，
                                    //赋值为 0表示用最快速度访问，不增加额外的等待时间
                                    
    P0M0 = 0x00; P0M1 = 0x00;       //设置P0口为准双向口模式
    P1M0 = 0x00; P1M1 = 0x00;       //设置P1口为准双向口模式
    P2M0 = 0x00; P2M1 = 0x00;       //设置P2口为准双向口模式
    P3M0 = 0x00; P3M1 = 0x00;       //设置P3口为准双向口模式
    P4M0 = 0x00; P4M1 = 0x00;       //设置P4口为准双向口模式
    P5M0 = 0x00; P5M1 = 0x00;       //设置P5口为准双向口模式
    P6M0 = 0x00; P6M1 = 0x00;       //设置P6口为准双向口模式
    P7M0 = 0x00; P7M1 = 0x00;       //设置P7口为准双向口模式
                                    //上面的将所有I/O口都初始化为准双向口工作模式的程序，
                                    //可以使用AIapp-ISP软件的“I/O口配置工具”来生成。
    usb_init();                     //USB CDC 接口配置
        IE2 |=0x80;                                                //使能USB中断                                                               
        Timer0_Init();
        EA = 1;
    P40 = 0;                        //打开LED部分的供电
        Count_ms[0] =0;
       
        while (DeviceState != DEVSTATE_CONFIGURED);//等待USB完成配置
    while(1)                        
    {   
                if (bUsbOutReady)
        {
           // USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
            usb_OUT_done();
        }
//                if(Count_ms[0]>=500)
//                {
//                        Count_ms[0] =0;
//                       
//                        num++;
//                        if(num>16)
//                                num=0;
//                }
               
                P0 = ~State[num];  //num取值0-7
                if(P32==0)
                {
                        Delay10ms();
                        if(P32==0)
                        {
                                while(P32 ==0);
                                        num++;
                                if(num>=16)
                                num=0;
                        }
                       
                }                       
}
}

void Timer0_Isr(void) interrupt 1  //1毫秒执行一次 在初始化配置好了
{
       
        for(i=0;i<3;i++)
        {
           Count_ms[i]++;
        }
}

下面的代码对按住p32不放做了改进 防止卡死
/*  
任务3 按键1按一下，LED灯动一下，使用计数器避免按键不放造成死机
   低LED0                  高LDE7
   
   8  4  2  1  8  4  2  1
   B0 B1 B2 B3 B4 B5 B6 B7
   0  1  1  1  1  1  1  1  
   1  0  1  1  1  1  1  1
   1  1  0  1  1  1  1  1  
   1  1  1  0  1  1  1  1  
   1  1  1  1  0  1  1  1  
   1  1  1  1  1  0  1  1
   1  1  1  1  1  1  0  1  
   1  1  1  1  1  1  1  0  

*/
#include <AI8051U.H>                //包含AI8051U的头文件
#include "intrins.h"                //使用_nop_()函数所必须要包含的头文件,
                                    //否则延时函数中调用的_nop_()函数没有被头文件引用过来，
                                    //会导致编译器找不到这个而函数而报错。
#include "stc32_stc8_usb.h"                                        //不断电下载头文件

#define u8 unsigned char  //unsigned char 0-255
#define u16 unsigned int  //unsigned int 0-65536



u8 num=0;

//u8 State[8]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80}; //建立一个数组用于单个流水灯
//u8 State[16]={0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00}; //从左向右到头再从右向左
u8 State[16]={0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00}; //从左向右到头再从右向左


u16 Count_ms[3]={0,0,0};    //三个计时器变量
u8 i;
u16 Key_Vol=0;                //按键按下计数
u16 Key_triggered =0;                         //按键触发标志（0 未触发，1触发）

                                    //上面延时函数部分代码可使用AIapp-ISP软件的“软件延时计算器”工具来生成。
void Timer0_Init(void)                //1毫秒@24.000MHz
{
        TM0PS = 0x00;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0x30;                                //设置定时初始值
        TH0 = 0xF8;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
        ET0 = 1;                                //使能定时器0中断
}


void main(void)
{
       

       
    EAXFR = 1;                      //允许访问扩展的特殊寄存器，XFR
                                    //(32 位模式请使用这句，注释下一句)
   // P_SW2 |= 0x80;                  //允许访问扩展的特殊寄存器，XFR
                                    //(8位模式请使用这句，注释上一句)。
    WTST = 0;                       //设置取程序代码等待时间，
                                    //赋值为 0表示不等待，程序以最快速度运行
    CKCON = 0;                      //设置访问片内的 xdata速度，
                                    //赋值为 0表示用最快速度访问，不增加额外的等待时间
                                    
    P0M0 = 0x00; P0M1 = 0x00;       //设置P0口为准双向口模式
    P1M0 = 0x00; P1M1 = 0x00;       //设置P1口为准双向口模式
    P2M0 = 0x00; P2M1 = 0x00;       //设置P2口为准双向口模式
    P3M0 = 0x00; P3M1 = 0x00;       //设置P3口为准双向口模式
    P4M0 = 0x00; P4M1 = 0x00;       //设置P4口为准双向口模式
    P5M0 = 0x00; P5M1 = 0x00;       //设置P5口为准双向口模式
    P6M0 = 0x00; P6M1 = 0x00;       //设置P6口为准双向口模式
    P7M0 = 0x00; P7M1 = 0x00;       //设置P7口为准双向口模式
                                    //上面的将所有I/O口都初始化为准双向口工作模式的程序，
                                    //可以使用AIapp-ISP软件的“I/O口配置工具”来生成。
    usb_init();                     //USB CDC 接口配置
        IE2 |=0x80;                                                //使能USB中断                                                               
        Timer0_Init();
        EA = 1;
    P40 = 0;                        //打开LED部分的供电

       
        while (DeviceState != DEVSTATE_CONFIGURED);//等待USB完成配置
    while(1)                        
    {   
                if (bUsbOutReady)
        {
           // USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
            usb_OUT_done();
        }
               
                P0 = ~State[num];  //num取值0-7
       
// 每10ms检测一次按键（利用定时器计数）
                if (Count_ms[2] >= 10)
                {
                        Count_ms[2] = 0;  // 重置10ms计数器
                       
                        if (P32 == 0)  // 按键按下（低电平）
                        {
                                Key_Vol++;  // 累计按下时间（每10ms加1）
                               
                                // 按下持续50ms（消抖）且未触发过，则执行一次LED变化
                                if (Key_Vol >= 5 && Key_triggered == 0)
                                {
                                        num++;
                                        if (num >= 16)  // 边界判断（0-15循环）
                                                num = 0;
                                        Key_triggered = 1;  // 标记为已触发，避免长按重复执行
                                }
                        }
                        else  // 按键释放（高电平）
                        {
                                Key_Vol = 0;  // 重置按下计数
                                Key_triggered = 0;  // 重置触发标志，允许下次触发
                        }
                }
        }
}

void Timer0_Isr(void) interrupt 1  //1毫秒执行一次 在初始化配置好了
{
       
        for(i=0;i<3;i++)
        {
           Count_ms[i]++;
        }
}

MJ***

今天学习了《Ai8051U》深度入门的第八节课的 ‘结构体数组的周期性任务调度’内容
学习了把main.c 里面的 函数保存为XX.c XX.h文件，XX.c里面放功能函数，xx.h里面放函数声明
视频中分别新建了 task.c task.h 和io.c io.h
--------------------------------------------------------------
在task.c中写了结构体数组的函数
#include "task.h"
#include "io.h"




static TASK_COMPONENTS Task_Comps[]=
{
//状态  计数  周期  函数
       
{0, 300,   300,   LED0_Blink},      /* task 1 Period： 300ms */
{0, 600,   600,   LED1_Blink},      /* task 1 Period： 600ms */
{0, 900,   900,   LED2_Blink},      /* task 1 Period： 600ms */  
{0, 10,    10,    KEY_Task},      /* task 1 Period： 600ms */         
};

u8 Tasks_Max = sizeof(Task_Comps)/sizeof(Task_Comps[0]);

//========================================================================
// 函数: Task_Handler_Callback
// 描述: 任务标记回调函数.
// 参数: None.
// 返回: None.
// 版本: V1.0, 2012-10-22
//========================================================================
void Task_Marks_Handler_Callback(void)
{
    u8 i;
    for(i=0; i<Tasks_Max; i++)
    {
        if(Task_Comps[i].TIMCount)      /* If the time is not 0 */
        {
            Task_Comps[i].TIMCount--;   /* Time counter decrement */
            if(Task_Comps[i].TIMCount == 0) /* If time arrives */
            {
                /*Resume the timer value and try again */
                Task_Comps[i].TIMCount = Task_Comps[i].TRITime;  
                Task_Comps[i].Run = 1;      /* The task can be run */
            }
        }
    }
}

//========================================================================
// 函数: Task_Pro_Handler_Callback
// 描述: 任务处理回调函数.
// 参数: None.
// 返回: None.
// 版本: V1.0, 2012-10-22
//========================================================================
void Task_Pro_Handler_Callback(void)
{
    u8 i;
    for(i=0; i<Tasks_Max; i++)
    {
        if(Task_Comps[i].Run) /* If task can be run */
        {
            Task_Comps[i].Run = 0;      /* Flag clear 0 */
            Task_Comps[i].TaskHook();   /* Run task */
        }
    }
}
--------------------------------------------------------
在task.h中写了结构体数组的声明
#ifndef __TASK_H
#define __TASK_H

#include "config.h"                        //调用头文件


typedef struct
{
        u8 Run;               //任务状态：Run/Stop
        u16 TIMCount;         //定时计数器
        u16 TRITime;          //重载计数器
        void (*TaskHook) (void); //任务函数
} TASK_COMPONENTS;   


void Task_Marks_Handler_Callback(void);
void Task_Pro_Handler_Callback(void);

#endif
typedef struct 规定了结构体数组里面的内容
----------------------------------------------------------
只是我现在还没理解 main.c 函数中 在while（1）里面的      Task_Pro_Handler_Callback();        //执行功能函数 和Task_Marks_Handler_Callback();                //系统计时
LED0_Blink、LED1_Blink、LED2_Blink 怎样在运行的时候不会相互干扰。

MJ***

仔细看了看代码，{0, 300, 300, LED0_Blink} ，{0, 600, 600, LED1_Blink} 是作为数组存在于 Task_Comps[] 数组中。
{0, 300, 300, LED0_Blink} 是第 0 个元素，{0, 600, 600, LED1_Blink} 是第 1个元素
就是说在 Task_Comps 数组的初始化列表中：
第一个元素 {0, 300, 300, LED0_Blink} 对应数组下标 0
第二个元素 {0, 600, 600, LED1_Blink} 对应数组下标 1
第三个元素 {0, 900, 900, LED2_Blink} 对应数组下标 2

因此，通过 Task_Comps[0] 可以访问到 LED0_Blink 对应的任务结构体，包括它的状态、计数器、周期和函数指针。