《8051U深度入门到32位51大型实战教学视频》学习心路历程

芯*** · 发表于 2025-1-22 11:50:30

第13集外部中断，已手敲代码，测试通过。

任务一：当按下外部中断INT1/P33，P01的LED改变原来的状态

截图202501221142407565.jpg

#include "io.h"

u8 State1 = 0;                                        //LED1初始状态
u8 State2 = 0;                                        //LED2初始状态
u8 State3 = 0;                                        //LED3初始状态

u16 Key_Vol ;                                //按键按下持续时间

u8 SEG_NUM[]=
{
    0x3F,       /*'0', 0*/
    0x06,       /*'1', 1*/
    0x5B,       /*'2', 2*/
    0x4F,       /*'3', 3*/
    0x66,       /*'4', 4*/
    0x6D,       /*'5', 5*/
    0x7D,       /*'6', 6*/
    0x07,       /*'7', 7*/
    0x7F,       /*'8', 8*/
    0x6F,       /*'9', 9*/
    0x77,       /*'A', 10*/
    0x7C,       /*'B', 11*/
    0x39,       /*'C', 12*/
    0x5E,       /*'D', 13*/
    0x79,       /*'E', 14*/
    0x71,       /*'F', 15*/
    0x40,       /*'-', 16*/
    0x00,       /*' ', 17*/
    0x80,       /*'.', 18*/
};

u8 T_NUM[8] = 
{
        0X01,0X02,0X04,0X08,0X10,0X20,0X40,0X80
};


void LED0_Blink(void)
{
        State1 = !State1;
        P00 = State1;
}

void LED1_Blink(void)
{
        State2 = !State2;
        P01 = State2;
}

void LED2_Blink(void)
{
        State3 = !State3;
        P02 = State3;
}

void KEY_Task(void)
{
        if( P33 == 0 )
        {
                Key_Vol++;
                if( Key_Vol==5 )
                {
                        //按键按下的任务
//                        printf( "按键单击\r\n" );
                        
                        USB_Reset_U();
                        
                        IAP_CONTR = 0X20;
                }
        }
        else
        {
                Key_Vol = 0;
        }
        
}

/*
        #define ROW1        P06                        //端口定义
        #define ROW2        P07
        #define COL1        P00
        #define COL2        P01
        #define COL3        P02
        #define COL4        P03
*/

u8 key_num = 0xff;

//任务1：数码管显示当前的按键号
void Task_1(void)
{
        //①第一步：现将P0.0-P0.3输出低电平，P0.6-P0.7输出高电平，如果有按键按下，按下的那一行的IO就会变成低电平，就可以判断出哪一行按下了。
        COL1 = 0;
        COL2 = 0;
        COL3 = 0;
        COL4 = 0;
        ROW1 = 1;
        ROW2 = 1;
        
        if(( ROW1 == 0 ) || ( ROW2 == 0 ))                //如果行按键有按下
        {
                if(( ROW1 ==0 ) && ( ROW2 ==0 ))        //如果两行都有按键按下，不处理
                {
                        
                }
                else if((( ROW1 ==1 )&&( ROW2 ==0 )) || (( ROW1 ==0 )&&( ROW2 ==1 )))        //如果有按键按下，而且只有一颗
                {
                        if( ROW1 ==0 )                                //判断哪一行，输出行开始的序号
                                key_num = 0;
                        else if( ROW2 ==0 )
                                key_num = 4;
                                
                        //②第二步：现将P0.0-P0.3输出高电平，P0.6-P0.7输出低电平，如果有按键按下，按下的那一列的IO就会变成低电平，就可以判断出哪一列按下了。
                        COL1 = 1;
                        COL2 = 1;
                        COL3 = 1;
                        COL4 = 1;
                        ROW1 = 0;
                        ROW2 = 0;
                        
                        if( COL1 ==0 )                                //判断哪一列，叠加按键的序号
                        {
//                                key_num = key_num ;
                        }
                        else if( COL2 ==0 )
                        {
                                key_num = key_num + 1;
                        }
                        else if( COL3 ==0 )
                        {
                                key_num = key_num + 2;
                        }
                        else if( COL4 ==0 )
                        {
                                key_num = key_num + 3;
                        }
                }
                COL1 = 0;
                COL2 = 0;
                COL3 = 0;
                COL4 = 0;
                ROW1 = 1;
                ROW2 = 1;                
        }
        else
        {
                key_num = 0xff;
        }
        
        //③第三步：行列组合一下就可以判断出是哪个按键按下了。

}



void Init_595(void)
{
        HC595_SER = 0;
        HC595_RCK = 0;
        HC595_SCK = 0;        
}
        


void Send_595( u8 dat )
{
        u8 i;
        
        for( i=0;i<8;i++ )
        {
                dat <<= 1;                                //DAT = (DAT<<1);        //CY
                HC595_SER = CY;                //先把数据写到引脚上
                HC595_SCK = 1;                        //输出上升沿的时钟信号
                HC595_SCK = 0;
        }
}

void Display_Seg(u8 HC595_1,u8 HC595_2)
{
        Send_595(HC595_1);                        //数码管段码输出  高电平点亮
        Send_595(HC595_2);                        //数码管位码      低电平点亮
        
        HC595_RCK = 1;                                //数据输出        
        HC595_RCK = 0;
}

//void SEG_Task(void)
//{
//        if( key_num == 255 )
//                Display_Seg( SEG_NUM[17] , ~T_NUM[0]);                //数码管刷段码和位码
//        else
//                Display_Seg( SEG_NUM[key_num] , ~T_NUM[0]);                //数码管刷段码和位码
//}

u8 passward[8] = { 16,16,16,16,16,16,16,16 };

u8 Seg_no = 0;
void SEG_Task(void)
{
        u8 num = 0;
        if( Seg_no ==0 )                                                                //小时十位
        {
                Display_Seg( SEG_NUM[passward[0]] , ~T_NUM[0]);                //数码管刷段码和位码
        }
        else if( Seg_no ==1 )                                                        //小时的个位
        {
                Display_Seg( SEG_NUM[passward[1]] , ~T_NUM[1]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==2 )                                                        //第一个横杠
        {
                Display_Seg( SEG_NUM[passward[2]] , ~T_NUM[2]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==3 )                                                        //分钟的十位
        {
                Display_Seg( SEG_NUM[passward[3]] , ~T_NUM[3]);                //数码管刷段码和位码
        }
        else if( Seg_no ==4 )
        {
                Display_Seg( SEG_NUM[passward[4]] , ~T_NUM[4]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==5 )
        {
                Display_Seg( SEG_NUM[passward[5]] , ~T_NUM[5]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==6 )
        {
                Display_Seg( SEG_NUM[passward[6]] , ~T_NUM[6]);                //数码管刷段码和位码
        }
        else if( Seg_no ==7 )
        {
                Display_Seg( SEG_NUM[passward[7]] , ~T_NUM[7]);                //数码管刷段码和位码
        }        
        else
        {
                
        }
        Seg_no ++;
        if( Seg_no>7 )
                Seg_no=0;
}

u8 Key_Vol3 = 0;
u8 key_no =0 ;

void PW_write_Task(void)
{
        if( key_num <0xff )
        {
                Key_Vol3 ++;
                if( Key_Vol3 == 5 )
                {
                        if( key_no == 0 )
                        {
                                passward[0] = 16;
                                passward[1] = 16;
                                passward[2] = 16;
                                passward[3] = 16;
                                passward[4] = 16;
                                passward[5] = 16;
                                passward[6] = 16;
                                passward[7] = 16;                        
                        }                                
                        passward[ key_no] = key_num ; 
                        key_no ++;
//                        passward[7] = 17;        
                        if( key_no == 8 )                //密码输入到了八位
                        {
                                if((passward[0]==1) && (passward[1]==2) && (passward[2]==3) && (passward[3]==4) && (passward[4]==5) && (passward[5]==6) && (passward[6]==7) &&(passward[7]==0) )  
                                {
                                        passward[0] = 17;
                                        passward[1] = 17;
                                        passward[2] = 17;
                                        passward[3] = 17;
                                        passward[4] = 17;
                                        passward[5] = 17;
                                        passward[6] = 17;
                                        passward[7] = 1;                                        
                                }
                                else
                                {
                                        passward[0] = 16;
                                        passward[1] = 16;
                                        passward[2] = 16;
                                        passward[3] = 16;
                                        passward[4] = 16;
                                        passward[5] = 16;
                                        passward[6] = 16;
                                        passward[7] = 16;                                
                                }
                                key_no = 0;
                        }
                }
        }
        else
        {
                Key_Vol3 = 0;
        }
}


void INT1_Init(void)
{
        IT1 = 1;                        //下降沿中断
        EX1 = 1;                        //打开中断允许
        EA = 1;                                //打开总中断
}

void INT_ISR(void) interrupt 2
{
        P01 = !P01;
}
复制代码

芯*** · 发表于 2025-1-23 14:49:31

第14集IO口中断，已手敲代码，测试通过
任务1：编写IO口中断程序
截图202501231412083917.jpg

#include "io.h"

u8 State1 = 0;                                        //LED1初始状态
u8 State2 = 0;                                        //LED2初始状态
u8 State3 = 0;                                        //LED3初始状态

u16 Key_Vol ;                                //按键按下持续时间

u8 SEG_NUM[]=
{
    0x3F,       /*'0', 0*/
    0x06,       /*'1', 1*/
    0x5B,       /*'2', 2*/
    0x4F,       /*'3', 3*/
    0x66,       /*'4', 4*/
    0x6D,       /*'5', 5*/
    0x7D,       /*'6', 6*/
    0x07,       /*'7', 7*/
    0x7F,       /*'8', 8*/
    0x6F,       /*'9', 9*/
    0x77,       /*'A', 10*/
    0x7C,       /*'B', 11*/
    0x39,       /*'C', 12*/
    0x5E,       /*'D', 13*/
    0x79,       /*'E', 14*/
    0x71,       /*'F', 15*/
    0x40,       /*'-', 16*/
    0x00,       /*' ', 17*/
    0x80,       /*'.', 18*/
};

u8 T_NUM[8] = 
{
        0X01,0X02,0X04,0X08,0X10,0X20,0X40,0X80
};


void LED0_Blink(void)
{
        State1 = !State1;
        P00 = State1;
}

void LED1_Blink(void)
{
        State2 = !State2;
        P01 = State2;
}

void LED2_Blink(void)
{
        State3 = !State3;
        P02 = State3;
}

void KEY_Task(void)
{
        if( P33 == 0 )
        {
                Key_Vol++;
                if( Key_Vol==5 )
                {
                        //按键按下的任务
//                        printf( "按键单击\r\n" );
                        
                        USB_Reset_U();
                        
                        IAP_CONTR = 0X20;
                }
        }
        else
        {
                Key_Vol = 0;
        }
        
}

/*
        #define ROW1        P06                        //端口定义
        #define ROW2        P07
        #define COL1        P00
        #define COL2        P01
        #define COL3        P02
        #define COL4        P03
*/

u8 key_num = 0xff;

//任务1：数码管显示当前的按键号
void Task_1(void)
{
        //①第一步：现将P0.0-P0.3输出低电平，P0.6-P0.7输出高电平，如果有按键按下，按下的那一行的IO就会变成低电平，就可以判断出哪一行按下了。
        COL1 = 0;
        COL2 = 0;
        COL3 = 0;
        COL4 = 0;
        ROW1 = 1;
        ROW2 = 1;
        
        if(( ROW1 == 0 ) || ( ROW2 == 0 ))                //如果行按键有按下
        {
                if(( ROW1 ==0 ) && ( ROW2 ==0 ))        //如果两行都有按键按下，不处理
                {
                        
                }
                else if((( ROW1 ==1 )&&( ROW2 ==0 )) || (( ROW1 ==0 )&&( ROW2 ==1 )))        //如果有按键按下，而且只有一颗
                {
                        if( ROW1 ==0 )                                //判断哪一行，输出行开始的序号
                                key_num = 0;
                        else if( ROW2 ==0 )
                                key_num = 4;
                                
                        //②第二步：现将P0.0-P0.3输出高电平，P0.6-P0.7输出低电平，如果有按键按下，按下的那一列的IO就会变成低电平，就可以判断出哪一列按下了。
                        COL1 = 1;
                        COL2 = 1;
                        COL3 = 1;
                        COL4 = 1;
                        ROW1 = 0;
                        ROW2 = 0;
                        
                        if( COL1 ==0 )                                //判断哪一列，叠加按键的序号
                        {
//                                key_num = key_num ;
                        }
                        else if( COL2 ==0 )
                        {
                                key_num = key_num + 1;
                        }
                        else if( COL3 ==0 )
                        {
                                key_num = key_num + 2;
                        }
                        else if( COL4 ==0 )
                        {
                                key_num = key_num + 3;
                        }
                }
                COL1 = 0;
                COL2 = 0;
                COL3 = 0;
                COL4 = 0;
                ROW1 = 1;
                ROW2 = 1;                
        }
        else
        {
                key_num = 0xff;
        }
        
        //③第三步：行列组合一下就可以判断出是哪个按键按下了。

}



void Init_595(void)
{
        HC595_SER = 0;
        HC595_RCK = 0;
        HC595_SCK = 0;        
}

void Send_595( u8 dat )
{
        u8 i;
        
        for( i=0;i<8;i++ )
        {
                dat <<= 1;                                //DAT = (DAT<<1);        //CY
                HC595_SER = CY;                //先把数据写到引脚上
                HC595_SCK = 1;                        //输出上升沿的时钟信号
                HC595_SCK = 0;
        }
}

void Display_Seg(u8 HC595_1,u8 HC595_2)
{
        Send_595(HC595_1);                        //数码管段码输出  高电平点亮
        Send_595(HC595_2);                        //数码管位码      低电平点亮
        
        HC595_RCK = 1;                                //数据输出        
        HC595_RCK = 0;
}

//void SEG_Task(void)
//{
//        if( key_num == 255 )
//                Display_Seg( SEG_NUM[17] , ~T_NUM[0]);                //数码管刷段码和位码
//        else
//                Display_Seg( SEG_NUM[key_num] , ~T_NUM[0]);                //数码管刷段码和位码
//}

u8 passward[8] = { 16,16,16,16,16,16,16,16 };

u8 Seg_no = 0;
void SEG_Task(void)
{
        u8 num = 0;
        if( Seg_no ==0 )                                                                //小时十位
        {
                Display_Seg( SEG_NUM[passward[0]] , ~T_NUM[0]);                //数码管刷段码和位码
        }
        else if( Seg_no ==1 )                                                        //小时的个位
        {
                Display_Seg( SEG_NUM[passward[1]] , ~T_NUM[1]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==2 )                                                        //第一个横杠
        {
                Display_Seg( SEG_NUM[passward[2]] , ~T_NUM[2]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==3 )                                                        //分钟的十位
        {
                Display_Seg( SEG_NUM[passward[3]] , ~T_NUM[3]);                //数码管刷段码和位码
        }
        else if( Seg_no ==4 )
        {
                Display_Seg( SEG_NUM[passward[4]] , ~T_NUM[4]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==5 )
        {
                Display_Seg( SEG_NUM[passward[5]] , ~T_NUM[5]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==6 )
        {
                Display_Seg( SEG_NUM[passward[6]] , ~T_NUM[6]);                //数码管刷段码和位码
        }
        else if( Seg_no ==7 )
        {
                Display_Seg( SEG_NUM[passward[7]] , ~T_NUM[7]);                //数码管刷段码和位码
        }        
        else
        {
                
        }
        Seg_no ++;
        if( Seg_no>7 )
                Seg_no=0;
}

u8 Key_Vol3 = 0;
u8 key_no =0 ;

void PW_write_Task(void)
{
        if( key_num <0xff )
        {
                Key_Vol3 ++;
                if( Key_Vol3 == 5 )
                {
                        if( key_no == 0 )
                        {
                                passward[0] = 16;
                                passward[1] = 16;
                                passward[2] = 16;
                                passward[3] = 16;
                                passward[4] = 16;
                                passward[5] = 16;
                                passward[6] = 16;
                                passward[7] = 16;                        
                        }                                
                        passward[ key_no] = key_num ; 
                        key_no ++;
//                        passward[7] = 17;        
                        if( key_no == 8 )                //密码输入到了八位
                        {
                                if((passward[0]==1) && (passward[1]==2) && (passward[2]==3) && (passward[3]==4) && (passward[4]==5) && (passward[5]==6) && (passward[6]==7) &&(passward[7]==0) )  
                                {
                                        passward[0] = 17;
                                        passward[1] = 17;
                                        passward[2] = 17;
                                        passward[3] = 17;
                                        passward[4] = 17;
                                        passward[5] = 17;
                                        passward[6] = 17;
                                        passward[7] = 1;                                        
                                }
                                else
                                {
                                        passward[0] = 16;
                                        passward[1] = 16;
                                        passward[2] = 16;
                                        passward[3] = 16;
                                        passward[4] = 16;
                                        passward[5] = 16;
                                        passward[6] = 16;
                                        passward[7] = 16;                                
                                }
                                key_no = 0;
                        }
                }
        }
        else
        {
                Key_Vol3 = 0;
        }
}

//void INT1_Init(void)
//{
//   IT1=1;   //下降沿中断
//         EX1=1;   //打开中断允许
//         EA=1;    // 打开总中断
//}

//void INT_ISR(void)interrupt 2
//{
//                P01=!P01;
//}

void P3_IO_Init(void)
{
                P3IM0=0X00;  //IO中断模式设置为下降沿
                P3IM1=0X00;
        
                P3INTE=0X08;  //打开中断
}

void P3_IO_ISR(void)    interrupt 40
{
                u8 intf;
        
                intf=P3INTF;
                
                if(intf)  //判断有没有io触发中断
                {
                        P3INTF=0;
                        
                        if (intf & 0x08)  //判断是否是P33按键按下
                        {
                                        P01=!P01;
                        }
                }
}
复制代码

任务2:编写P4端口的I0中断打断 P3低电平中断的的程序
1、设置P33优先级比P47高按下P33显示1，按下P47显示2，P33高优先级可以打断P47低优先级中断

截图202501231428468506.jpg

#include "io.h"

u8 State1 = 0;                                        //LED1初始状态
u8 State2 = 0;                                        //LED2初始状态
u8 State3 = 0;                                        //LED3初始状态

u16 Key_Vol ;                                //按键按下持续时间

u8 SEG_NUM[]=
{
    0x3F,       /*'0', 0*/
    0x06,       /*'1', 1*/
    0x5B,       /*'2', 2*/
    0x4F,       /*'3', 3*/
    0x66,       /*'4', 4*/
    0x6D,       /*'5', 5*/
    0x7D,       /*'6', 6*/
    0x07,       /*'7', 7*/
    0x7F,       /*'8', 8*/
    0x6F,       /*'9', 9*/
    0x77,       /*'A', 10*/
    0x7C,       /*'B', 11*/
    0x39,       /*'C', 12*/
    0x5E,       /*'D', 13*/
    0x79,       /*'E', 14*/
    0x71,       /*'F', 15*/
    0x40,       /*'-', 16*/
    0x00,       /*' ', 17*/
    0x80,       /*'.', 18*/
};

u8 T_NUM[8] = 
{
        0X01,0X02,0X04,0X08,0X10,0X20,0X40,0X80
};


void LED0_Blink(void)
{
        State1 = !State1;
        P00 = State1;
}

void LED1_Blink(void)
{
        State2 = !State2;
        P01 = State2;
}

void LED2_Blink(void)
{
        State3 = !State3;
        P02 = State3;
}

void KEY_Task(void)
{
        if( P33 == 0 )
        {
                Key_Vol++;
                if( Key_Vol==5 )
                {
                        //按键按下的任务
//                        printf( "按键单击\r\n" );
                        
                        USB_Reset_U();
                        
                        IAP_CONTR = 0X20;
                }
        }
        else
        {
                Key_Vol = 0;
        }
        
}

/*
        #define ROW1        P06                        //端口定义
        #define ROW2        P07
        #define COL1        P00
        #define COL2        P01
        #define COL3        P02
        #define COL4        P03
*/

u8 key_num = 0xff;

//任务1：数码管显示当前的按键号
void Task_1(void)
{
        //①第一步：现将P0.0-P0.3输出低电平，P0.6-P0.7输出高电平，如果有按键按下，按下的那一行的IO就会变成低电平，就可以判断出哪一行按下了。
        COL1 = 0;
        COL2 = 0;
        COL3 = 0;
        COL4 = 0;
        ROW1 = 1;
        ROW2 = 1;
        
        if(( ROW1 == 0 ) || ( ROW2 == 0 ))                //如果行按键有按下
        {
                if(( ROW1 ==0 ) && ( ROW2 ==0 ))        //如果两行都有按键按下，不处理
                {
                        
                }
                else if((( ROW1 ==1 )&&( ROW2 ==0 )) || (( ROW1 ==0 )&&( ROW2 ==1 )))        //如果有按键按下，而且只有一颗
                {
                        if( ROW1 ==0 )                                //判断哪一行，输出行开始的序号
                                key_num = 0;
                        else if( ROW2 ==0 )
                                key_num = 4;
                                
                        //②第二步：现将P0.0-P0.3输出高电平，P0.6-P0.7输出低电平，如果有按键按下，按下的那一列的IO就会变成低电平，就可以判断出哪一列按下了。
                        COL1 = 1;
                        COL2 = 1;
                        COL3 = 1;
                        COL4 = 1;
                        ROW1 = 0;
                        ROW2 = 0;
                        
                        if( COL1 ==0 )                                //判断哪一列，叠加按键的序号
                        {
//                                key_num = key_num ;
                        }
                        else if( COL2 ==0 )
                        {
                                key_num = key_num + 1;
                        }
                        else if( COL3 ==0 )
                        {
                                key_num = key_num + 2;
                        }
                        else if( COL4 ==0 )
                        {
                                key_num = key_num + 3;
                        }
                }
                COL1 = 0;
                COL2 = 0;
                COL3 = 0;
                COL4 = 0;
                ROW1 = 1;
                ROW2 = 1;                
        }
        else
        {
                key_num = 0xff;
        }
        
        //③第三步：行列组合一下就可以判断出是哪个按键按下了。

}



void Init_595(void)
{
        HC595_SER = 0;
        HC595_RCK = 0;
        HC595_SCK = 0;        
}
        


void Send_595( u8 dat )
{
        u8 i;
        
        for( i=0;i<8;i++ )
        {
                dat <<= 1;                                //DAT = (DAT<<1);        //CY
                HC595_SER = CY;                //先把数据写到引脚上
                HC595_SCK = 1;                        //输出上升沿的时钟信号
                HC595_SCK = 0;
        }
}

void Display_Seg(u8 HC595_1,u8 HC595_2)
{
        Send_595(HC595_1);                        //数码管段码输出  高电平点亮
        Send_595(HC595_2);                        //数码管位码      低电平点亮
        
        HC595_RCK = 1;                                //数据输出        
        HC595_RCK = 0;
}

//void SEG_Task(void)
//{
//        if( key_num == 255 )
//                Display_Seg( SEG_NUM[17] , ~T_NUM[0]);                //数码管刷段码和位码
//        else
//                Display_Seg( SEG_NUM[key_num] , ~T_NUM[0]);                //数码管刷段码和位码
//}

u8 passward[8] = { 17,17,17,17,17,17,17,17 };

u8 Seg_no = 0;
void SEG_Task(void)
{
        u8 num = 0;
        if( Seg_no ==0 )                                                                //小时十位
        {
                Display_Seg( SEG_NUM[passward[0]] , ~T_NUM[0]);                //数码管刷段码和位码
        }
        else if( Seg_no ==1 )                                                        //小时的个位
        {
                Display_Seg( SEG_NUM[passward[1]] , ~T_NUM[1]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==2 )                                                        //第一个横杠
        {
                Display_Seg( SEG_NUM[passward[2]] , ~T_NUM[2]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==3 )                                                        //分钟的十位
        {
                Display_Seg( SEG_NUM[passward[3]] , ~T_NUM[3]);                //数码管刷段码和位码
        }
        else if( Seg_no ==4 )
        {
                Display_Seg( SEG_NUM[passward[4]] , ~T_NUM[4]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==5 )
        {
                Display_Seg( SEG_NUM[passward[5]] , ~T_NUM[5]);                //数码管刷段码和位码
        }        
        else if( Seg_no ==6 )
        {
                Display_Seg( SEG_NUM[passward[6]] , ~T_NUM[6]);                //数码管刷段码和位码
        }
        else if( Seg_no ==7 )
        {
                Display_Seg( SEG_NUM[passward[7]] , ~T_NUM[7]);                //数码管刷段码和位码
        }        
        else
        {
                
        }
        Seg_no ++;
        if( Seg_no>7 )
                Seg_no=0;
}

u8 Key_Vol3 = 0;
u8 key_no =0 ;

void PW_write_Task(void)
{
        if( key_num <0xff )
        {
                Key_Vol3 ++;
                if( Key_Vol3 == 5 )
                {
                        if( key_no == 0 )
                        {
                                passward[0] = 16;
                                passward[1] = 16;
                                passward[2] = 16;
                                passward[3] = 16;
                                passward[4] = 16;
                                passward[5] = 16;
                                passward[6] = 16;
                                passward[7] = 16;                        
                        }                                
                        passward[ key_no] = key_num ; 
                        key_no ++;
//                        passward[7] = 17;        
                        if( key_no == 8 )                //密码输入到了八位
                        {
                                if((passward[0]==1) && (passward[1]==2) && (passward[2]==3) && (passward[3]==4) && (passward[4]==5) && (passward[5]==6) && (passward[6]==7) &&(passward[7]==0) )  
                                {
                                        passward[0] = 17;
                                        passward[1] = 17;
                                        passward[2] = 17;
                                        passward[3] = 17;
                                        passward[4] = 17;
                                        passward[5] = 17;
                                        passward[6] = 17;
                                        passward[7] = 1;                                        
                                }
                                else
                                {
                                        passward[0] = 16;
                                        passward[1] = 16;
                                        passward[2] = 16;
                                        passward[3] = 16;
                                        passward[4] = 16;
                                        passward[5] = 16;
                                        passward[6] = 16;
                                        passward[7] = 16;                                
                                }
                                key_no = 0;
                        }
                }
        }
        else
        {
                Key_Vol3 = 0;
        }
}


//void INT1_Init(void)
//{
//   IT1=1;   //下降沿中断
//         EX1=1;   //打开中断允许
//         EA=1;    // 打开总中断
//}

//void INT_ISR(void)interrupt 2
//{
//                P01=!P01;
//}

void P3_IO_Init(void)
{
                P3IM0=0X00;  //IO中断模式设置为下降沿
                P3IM1=0Xff;
        
                P3INTE=0X08;  //打开中断
}

void P3_IO_ISR(void)    interrupt 40
{
                u8 intf;
        
                intf=P3INTF;
                
                if(intf)  //判断有没有io触发中断
                {
                        P3INTF=0;
                        
                        if (intf & 0x08)  //判断是否是P33按键按下
                        {
                                passward[0] = 1;
                                        //P01=!P01;
                        }
                }
}        

void P4_IO_Init(void)
{
                P4IM0=0X00;  //IO中断模式设置为下降沿
                P4IM1=0Xff;
        
                P4INTE=0X80;  //打开中断
        
        PINIPH  |= (1<<4);   //写入最高优先级
        PINIPL  |= (1<<4);
}

void P4_IO_ISR(void)    interrupt 41
{
                u8 intf;
        
                intf=P4INTF;
                
                if(intf)  //判断有没有io触发中断
                {
                        P4INTF=0;
                        
                        if (intf & 0x80)  //判断是否是P33按键按下
                        {
                                        passward[0] = 2;
                        }
                }
}        
复制代码

2、设置P47优先级比P33高按下P33显示1，按下P47显示2，P47高优先级可以打断P33低优先级中断

截图202501231444213217.jpg

芯*** · 发表于 2025-1-24 11:50:37

第15集定时器做计数器，已手敲代码，测试通过

任务1：编写定时器1计数的程序为了方便计数，10个脉冲中断一次

1

#include "tim.h"


u32 Count_T1 = 0;

void TIM1_Count_Init(void)
{
        T1_CT = 1;       //设置为外部计数
        T1_M1 = 0;       //设置为16位自动重载
        T1_M0 = 0;
        T1_GATE = 0;
        
        TH1 = (65536-Count_num)>>8;     //65526
        TL1 = (65536-Count_num);
        
        P3PU |= 0x20; 

        TR1 = 1;      //启动定时器1
        ET1 = 1;      //打开定时器1外部中断
        
}


void Timer1_Isr(void) interrupt 3                //1MS执行一次
{
    Count_T1 ++;     //T1引脚检测到十个脉冲就会溢出一次
}

void T1_RunTask(void)
{
        u32 count_th_tl = 0;
        count_th_tl = ((u16)TH1 <<8) + (u16)TL1;
        count_th_tl -= 65526;
        
        SEG7_ShowLong(Count_T1*Count_num+count_th_tl,10);
}
复制代码

任务2 ：编写INT1测量低电平时间（由按键模拟信号，100us的计数周期计数）
截图202501241324488014.jpg

#include "tim.h"


u32 Count_T1 = 0;

//void TIM1_Count_Init(void)
//{
//        T1_CT = 1;                        //设置为外部计数
//        T1_M1 = 0;                        //设置为16位自动重载
//        T1_M0 = 0;
//        T1_GATE = 0;
//        
//        TH1 = (65536-Count_num)>>8;        //65526 
//        TL1 = (65536-Count_num);
//        
//        P3PU |= 0x20; 

//        TR1 = 1;                        //启动定时器1
//        ET1 = 1;                        //打开定时器1外部中断
//        
//}


//void Timer1_Isr(void) interrupt 3                //1MS执行一次
//{
//        Count_T1 ++;                        //T1引脚检测到十个脉冲就会溢出一次
//}

//void T1_RunTask(void)
//{
//        u32 count_th_tl = 0;
//        count_th_tl = ((u16)TH1 << 8) + (u16)TL1;
//        count_th_tl -= 65526;
//        
//        SEG7_ShowLong(Count_T1*Count_num+count_th_tl,10);
//}

void Timer1_Isr(void) interrupt 3
{
                static u32 count_p33 = 0;
        
        if( P33 == 0 )                //按键按下开始计数
        {
                count_p33 ++ ;
        }
        else
        {
                if( count_p33>0 )                //表示之前按下了这个按键
                {
                        Count_T1 = count_p33;
                }
                count_p33 =0;
        }
}

void Timer1_Init(void)                //100微秒@24.000MHz
{
        AUXR &= 0xBF;                        //定时器时钟12T模式
        TMOD &= 0x0F;                        //设置定时器模式
        TL1 = 0x38;                                //设置定时初始值
        TH1 = 0xFF;                                //设置定时初始值
        TF1 = 0;                                //清除TF1标志
        TR1 = 1;                                //定时器1开始计时
        ET1 = 1;                                //使能定时器1中断
}
void T1_RunTask(void)
{
        //SEG7_ShowLong(Count_T1,10);        //显示整数
        SEG7_ShowString("%07.01f",((float)Count_T1)/10);
}
复制代码

芯*** · 发表于 2025-2-5 16:09:27

第16集DS18B20测温，已手敲代码，测试通过。
数码管显示室温，捏住测温传感器，温度逐渐上升。

截图202502051607135604.jpg

#include "18b20.h"

u8  MinusFlag = 0;                //如果等于0 ，正数；等于1，负数
u32 Temp_18b20;                //最终的温度，0.0625

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

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

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

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

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

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


//复位（输出0保持480us，输出1保持60us，读取当前电平，延时420us）
void DS18B20_Reset(void)
{
        u8 flag = 1;
        
        while( flag )                //只要括号里的变量大于0，就会一直执行
        {
                DQ = 0;
                Delay480us();
                DQ = 1;
                Delay60us();
                flag = DQ;                        //设备存在，会拉低总线
                Delay480us();
        }
}
        
//写逻辑0（输出0保持60us+，输出1保持1us+）
void DS18B20_Write_0(void)
{
        DQ = 0;
        Delay60us();
        DQ = 1;
        Delay1us();
        Delay1us();
}

//写逻辑1（输出0保持1us+，输出1保持60us+）
void DS18B20_Write_1(void)
{
        DQ = 0;
        Delay1us();
        Delay1us();
        DQ = 1;
        Delay60us();
}

//读逻辑0/1（输出0保持1us+，输出1保持1us+，读取当前电平，延时60us）
bit DS18B20_Read(void)
{
        bit state = 0;
        
        DQ = 0;
        Delay1us();
        Delay1us();        
        DQ = 1;
        Delay1us();
        Delay1us();        
        state = DQ;                //暂时保存这个DQ的数值
        Delay60us();
        
        return state;
}


//写1字节（先输出低位，在输出高位）
void DS18B20_WriteByte( u8 dat )
{
        u8 i;
        for(i=0;i<8;i++)
        {
                if( dat & 0x01 )        //最低位是1.发逻辑1电平
                {
                        DS18B20_Write_1();
                }
                else                                //否则.发逻辑0电平
                {
                        DS18B20_Write_0();
                }
                dat >>= 1;                        //dat = (dat>>1);
        }
}

//读1字节（先读到的是低位，后读到的是高位）
u8 DS18B20_ReadByte(void )
{
        u8 i;
        u8 dat=0;                                //数据暂存，
        
        for(i=0;i<8;i++)                //循环读取八次
        {
                dat >>= 1;
                if( DS18B20_Read() )        //如果读回来的是逻辑1   //0000 0000  ->1000 0000 -> 0100 0000
                {
                        dat |= 0x80;
                }
                else
                {
                }
        }
        return dat;
}


//复位-CCH-44H-等待-复位-CCH-BEH-读取2字节温度数据-换算）
void DS18B20_ReadTemp(void)
{
        u8 TempH = 0;
        u8 TempL = 0;
        u16 Temp = 0;
//---------------------发送检测命令---------------------        
        DS18B20_Reset();                        //1.发送复位命令
        DS18B20_WriteByte(0xcc);        //2.跳过ROM命令
        DS18B20_WriteByte(0x44);        //3.开始转化命令
        while( !DQ );                                //4.等待这个引脚变成高电平
        
//---------------------发送读取命令---------------------        
        DS18B20_Reset();                        //1.发送复位命令
        DS18B20_WriteByte(0xcc);        //2.跳过ROM命令
        DS18B20_WriteByte(0xBE);        //3.开始转化命令        
        TempL = DS18B20_ReadByte(); //读取低字节温度
        TempH = DS18B20_ReadByte(); //读取高字节温度        
        
        if( TempH & 0x80 )                        //如果最高位是1，这个就是负数
        {
                MinusFlag = 1;
                Temp = (((u16)TempH << 8) | ((u16)TempL << 0));
                Temp = (~Temp) +1;
                Temp_18b20 = (u32)Temp*625;
        }
        else
        {
                MinusFlag = 0;
                Temp = (((u16)TempH << 8) | ((u16)TempL << 0));
                Temp_18b20 = (u32)Temp*625;
        }
}
复制代码

芯*** · 发表于 2025-2-14 10:13:36

第17集串口的简单应用，已手敲代码，测试通过。

截图202502141008585970.jpg

#include "usart.h"
#include "io.h"

u8 Rec_Dat[50];  //接收缓冲区
u8 Rec_Num=0;    //接收计数
bit B_TX2_Busy=0;

void Uart2_Isr(void) interrupt 8
{
        if (S2CON & 0x02)        //检测串口2发送中断
        {
                S2CON &= ~0x02;        //清除串口2发送中断请求位
                B_TX2_Busy=0;
        }
        if (S2CON & 0x01)        //检测串口2接收中断
        {
                S2CON &= ~0x01;        //清除串口2接收中断请求位
                Rec_Dat[Rec_Num++]=S2BUF;
        }
}

void Uart2_Init(void)        //9600bps@24.000MHz
{
        P_SW2 |= 0x01;                                                //UART2/USART2: RxD2(P4.6), TxD2(P4.7)

        S2CON = 0x50;                //8位数据,可变波特率
        AUXR |= 0x04;                //定时器时钟1T模式
        T2L = 0x8F;                        //设置定时初始值
        T2H = 0xFD;                        //设置定时初始值
        AUXR |= 0x10;                //定时器2开始计时
        IE2 |= 0x01;                //使能串口2中断
        
        Rec_Num=0;
        B_TX2_Busy=0;
}

void Uart2_SendStr(u8 *puts)   //串口数据发送函数
{
        for(; *puts !=0;  puts++)     //遇到停止符0结束
        {
                S2BUF = *puts;
                B_TX2_Busy=1;
                while(B_TX2_Busy);
        }
}

//1.发送OPEN\r\n打开数码管，数码管显示“----”
//2.发送CLOSE\r\n打开数码管，数码管全部熄灭

void Usart2_RunTask(void)
{
         if(Rec_Num>=6)     //是否接收到了6位以上的数据
         {
                 if ((Rec_Dat[Rec_Num-1]=='\n') && (Rec_Dat[Rec_Num-2]=='\r'))  //末尾判断
                 {
                          if((Rec_Dat[Rec_Num-6]=='O') && (Rec_Dat[Rec_Num-5]=='P') && (Rec_Dat[Rec_Num-4]=='E') && (Rec_Dat[Rec_Num-3]=='N'))
                          {
                                  passward[0]=16;
                  passward[1]=16;
                  passward[2]=16;
                  passward[3]=16;
                                  Uart2_SendStr("打开成功！\r\n");
                          }
                          else if((Rec_Dat[Rec_Num-7]=='C') && (Rec_Dat[Rec_Num-6]=='L') && (Rec_Dat[Rec_Num-5]=='O') && (Rec_Dat[Rec_Num-4]=='S')&& (Rec_Dat[Rec_Num-3]=='E')) 
              {
                  passward[0]=17;
                  passward[1]=17;
                  passward[2]=17;
                  passward[3]=17;
                                  Uart2_SendStr("关闭成功！\r\n");
                      }
                           Rec_Num=0;
             }
     } 
 }
复制代码

芯*** · 发表于 2025-3-11 13:35:11

第18集串口的高级应用，已手敲代码，测试通过
任务1：使用奇校验，8位数据位，1位停止位的数据，发送"OPEN\r\n"

#include "usart.h"
#include "io.h"

u8 Rec_Dat[50];  //接收缓冲区
u8 Rec_Num=0; //接收计数
bit B_TX2_Busy=0;

void Uart2_Isr(void) interrupt 8
{
      u8 dat;
      if (S2CON & 0x02)       //检测串口2发送中断
      {
            S2CON &= ~0x02;       //清除串口2发送中断请求位
            B_TX2_Busy=0;
      }
      if (S2CON & 0x01)       //检测串口2接收中断
      {
            S2CON &= ~0x01;       //清除串口2接收中断请求位
            dat = S2BUF;
            ACC = dat;
            if(S2RB8 == (!P))  //奇校验
            Rec_Dat[Rec_Num++]=dat;
      }
}

void Uart2_Init(void)       //9600bps@24.000MHz
{
      P_SW2 |= 0x01;                                              //UART2/USART2: RxD2(P4.6), TxD2(P4.7)

S2CON = 0xD0;             //9位数据,可变波特率
      AUXR |= 0x04;             //定时器时钟1T模式
      T2L = 0x8F;                      //设置定时初始值
      T2H = 0xFD;                      //设置定时初始值
      AUXR |= 0x10;             //定时器2开始计时
      IE2 |= 0x01;             //使能串口2中断

      Rec_Num=0;
      B_TX2_Busy=0;
}

void Uart2_SendStr(u8 *puts) //串口数据发送函数
{
         u8 dat;
      for(; *puts !=0;  puts++)    //遇到停止符0结束
      {
                        dat = *puts;
                        ACC = dat;
                     if(P)
                              S2TB8 = 0;
                     else
                              S2TB8 = 1;
            S2BUF = dat;
            B_TX2_Busy=1;
            while(B_TX2_Busy);
      }
}

//1.发送OPEN\r\n打开数码管，数码管显示“----”
//2.发送CLOSE\r\n打开数码管，数码管全部熄灭

void Usart2_RunTask(void)
{
      if(Rec_Num>=6)    //是否接收到了6位以上的数据
      {
               if ((Rec_Dat[Rec_Num-1]=='\n') && (Rec_Dat[Rec_Num-2]=='\r'))  //末尾判断
               {
                        if((Rec_Dat[Rec_Num-6]=='O') && (Rec_Dat[Rec_Num-5]=='P') && (Rec_Dat[Rec_Num-4]=='E') && (Rec_Dat[Rec_Num-3]=='N'))
                        {
                              passward[0]=16;
               passward[1]=16;
               passward[2]=16;
               passward[3]=16;
                              Uart2_SendStr("打开成功！\r\n");
                        }
                        else if((Rec_Dat[Rec_Num-7]=='C') && (Rec_Dat[Rec_Num-6]=='L') && (Rec_Dat[Rec_Num-5]=='O') && (Rec_Dat[Rec_Num-4]=='S')&& (Rec_Dat[Rec_Num-3]=='E'))
            {
               passward[0]=17;
               passward[1]=17;
               passward[2]=17;
               passward[3]=17;
                              Uart2_SendStr("关闭成功！\r\n");
                  }
                        Rec_Num=0;
         }
   }
}

任务2：串口超时中断

#include "usart.h"
#include "io.h"

u8 Rec_Dat[50];  //接收缓冲区
u8 Rec_Num=0;    //接收计数
bit B_TX2_Busy=0;
u8 B_RX2_OK = 0;        //串口接收完成标志位

void Uart2_Isr(void) interrupt 8
{
        if (S2CON & 0x02)        //检测串口2发送中断
        {
                S2CON &= ~0x02;        //清除串口2发送中断请求位
                B_TX2_Busy=0;
        }
        if (S2CON & 0x01)        //检测串口2接收中断
        {
                S2CON &= ~0x01;        //清除串口2接收中断请求位
                
                UR2TOCR = 0xe0;                             //开启超时中断，使用系统时钟
                
                Rec_Dat[Rec_Num++]=S2BUF;
        }
        
         if(UR2TOSR & 0x01)                              //串口超时中断
    {
        B_RX2_OK = 1;                               //接收完成标志位
        UR2TOSR = 0x00;                             //清除超时标志位
        UR2TOCR = 0x00;                             //关闭超时中断
    } 
}

void Uart2_Init(void)        //9600bps@24.000MHz
{
        P_SW2 |= 0x01;                                                //UART2/USART2: RxD2(P4.6), TxD2(P4.7)

        S2CON = 0x50;                //8位数据,可变波特率
        AUXR |= 0x04;                //定时器时钟1T模式
        T2L = 0x8F;                        //设置定时初始值
        T2H = 0xFD;                        //设置定时初始值
        AUXR |= 0x10;                //定时器2开始计时
        IE2 |= 0x01;                //使能串口2中断
        
        UR2TOCR = 0x00;          //关闭超时中断                               
    UR2TOTL = 0x04;                                 
    UR2TOTH = 0x3b;                               
    UR2TOTE = 0x01; 
        
        Rec_Num=0;
        B_TX2_Busy=0;
        B_RX2_OK = 0;
}

void Uart2_SendStr(u8 *puts)   //串口数据发送函数
{
        for(; *puts !=0;  puts++)     //遇到停止符0结束
        {
                S2BUF = *puts;
                B_TX2_Busy=1;
                while(B_TX2_Busy);
        }
}

//1.发送OPEN\r\n打开数码管，数码管显示“----”
//2.发送CLOSE\r\n打开数码管，数码管全部熄灭

void Usart2_RunTask(void)
{
        if( B_RX2_OK == 1 )
        {
                B_RX2_OK = 0;
                Uart2_SendStr( "接收成功！\r\n" );
        }
//        if( Rec_Num >= 6 )                //是否接收到了6位以上的数据
//        {
//                if(( Rec_Dat[Rec_Num-1] == '\n' ) && ( Rec_Dat[Rec_Num-2] == '\r' ) )        //末尾判断
//                {
//                        if( ( Rec_Dat[Rec_Num-6] == 'O' ) && ( Rec_Dat[Rec_Num-5] == 'P' ) && ( Rec_Dat[Rec_Num-4] == 'E' ) && ( Rec_Dat[Rec_Num-3] == 'N' )  )
//                        {
//                                passward[0] = 16;
//                                passward[1] = 16;
//                                passward[2] = 16;
//                                passward[3] = 16;
//                                Uart2_SendStr( "打开成功！\r\n" );
//                        }
//                        else if( ( Rec_Dat[Rec_Num-7] == 'C' ) && ( Rec_Dat[Rec_Num-6] == 'L' ) && ( Rec_Dat[Rec_Num-5] == 'O' ) && ( Rec_Dat[Rec_Num-4] == 'S' ) && ( Rec_Dat[Rec_Num-3] == 'E' )  )
//                        {
//                                passward[0] = 17;
//                                passward[1] = 17;
//                                passward[2] = 17;
//                                passward[3] = 17;
//                                Uart2_SendStr( "关闭成功！\r\n" );
//                        }
//                        Rec_Num = 0;
//                }
//        }
}
复制代码

芯*** · 发表于 2025-3-11 13:40:54

第19集 ADC，已手敲代码，测试通过
任务1：编写ADC读取函数，并在数码管显示当前ADC数值
截图202503111337542233.jpg

任务2 ：编写ADC按键读取函数，并在数码管上显示当前按键号
截图202503111339555474.jpg

#include "adc.h"

void AdcSetRate(void)                //50KSPS@24.000MHz
{
        ADCCFG &= ~0x0f;
        ADCCFG |= 0x04;                        //SPEED(4)
        ADCTIM = 0xbf;                        //CSSETUP(1), CSHOLD(1), SMPDUTY(31)
}

void ADC_Init(void)
{
        //1.初始化IO为高祖输入
        P1M0 &= ~0x01; P1M1 |= 0x01; 

        //2.初始化ADC速度
        AdcSetRate();
        
        //3.对齐模式
        ADCCFG |= 0x20;
        
        //4.打开ADC电源
        ADC_POWER = 1;
}

u16 ADC_Read(u8 no)
{
        u16 adcval = 0;
        ADC_CONTR &= 0Xf0;                //清空低四位
        ADC_CONTR |= no;
        
        ADC_START = 1;                        //启动ADC转化
        _nop_();
        _nop_();
        while( !ADC_FLAG );                //等待采集完成
        ADC_FLAG = 0;                        //手动清空
        
        adcval = (((u16)ADC_RES) << 8) + (ADC_RESL);        //获取到最终的ADC数值
        
        return adcval;
}

//   (256-64) - (256+64)
//   (512-64) - (512+64)

#define ADC_OFFEST 64

u8 ADC_KEY_READ( u16 adc )        //返回值1-16分别对应16个按键
{
        u16 i;
        // 1.判断当前有没有按键按下
        if(  adc < (256 - ADC_OFFEST) )
        {
                return 0;
        }
        else                                                        //按键按下了
        {
                for( i=1;i<=16;i++ )
                {
                        if(( adc >= ( i*256-ADC_OFFEST ) ) &&( adc <= ( i*256+ADC_OFFEST )))
                        {
                                return i;
                        }
                }
        }
        return 0;
}
复制代码

芯*** · 发表于 2025-3-13 14:36:51

第20集 ADC_NTC测温，已手敲代码，测试通过
任务1：ADC采集NTC换算内温度
截图202503131437511297.jpg

#include "adc.h"

void AdcSetRate(void)                //50KSPS@24.000MHz
{
        ADCCFG &= ~0x0f;
        ADCCFG |= 0x04;                        //SPEED(4)
        ADCTIM = 0xbf;                        //CSSETUP(1), CSHOLD(1), SMPDUTY(31)
}

void ADC_Init(void)
{
        P5M0 |= 0x02; P5M1 &= ~0x02; 
    P51 = 1;
        
        //1.初始化IO为高祖输入
        P1M0 &= ~0x01; P1M1 |= 0x01; 
    P1M0 &= ~0x08; P1M1 |= 0x08; 

        //2.初始化ADC速度
        AdcSetRate();
        
        //3.对齐模式
        ADCCFG |= 0x20;
        
        //4.打开ADC电源
        ADC_POWER = 1;
}

u16 ADC_Read(u8 no)
{
        u16 adcval = 0;
        ADC_CONTR &= 0Xf0;                //清空低四位
        ADC_CONTR |= no;
        
        ADC_START = 1;                        //启动ADC转化
        _nop_();
        _nop_();
        while( !ADC_FLAG );                //等待采集完成
        ADC_FLAG = 0;                        //手动清空
        
        adcval = (((u16)ADC_RES) << 8) + (ADC_RESL);        //获取到最终的ADC数值
        
        return adcval;
}

//   (256-64) - (256+64)
//   (512-64) - (512+64)

#define ADC_OFFEST 64

u8 ADC_KEY_READ( u16 adc )        //返回值1-16分别对应16个按键
{
        u16 i;
        // 1.判断当前有没有按键按下
        if(  adc < (256 - ADC_OFFEST) )
        {
                return 0;
        }
        else                                                        //按键按下了
        {
                for( i=1;i<=16;i++ )
                {
                        if(( adc >= ( i*256-ADC_OFFEST ) ) &&( adc <= ( i*256+ADC_OFFEST )))
                        {
                                return i;
                        }
                }
        }
        return 0;
}

u16 code Temp_Tab[]=
{
140 ,
149 ,
159 ,
168 ,
178 ,
188 ,
199 ,
210 ,
222 ,
233 ,
246 ,
259 ,
272 ,
286 ,
301 ,
317 ,
333 ,
349 ,
367 ,
385 ,
403 ,
423 ,
443 ,
464 ,
486 ,
509 ,
533 ,
558 ,
583 ,
610 ,
638 ,
667 ,
696 ,
727 ,
758 ,
791 ,
824 ,
858 ,
893 ,
929 ,
965 ,
1003,
1041,
1080,
1119,
1160,
1201,
1243,
1285,
1328,
1371,
1414,
1459,
1503,
1548,
1593,
1638,
1684,
1730,
1775,
1821,
1867,
1912,
1958,
2003,
2048,
2093,
2137,
2182,
2225,
2269,
2312,
2354,
2397,
2438,
2479,
2519,
2559,
2598,
2637,
2675,
2712,
2748,
2784,
2819,
2853,
2887,
2920,
2952,
2984,
3014,
3044,
3073,
3102,
3130,
3157,
3183,
3209,
3234,
3259,
3283,
3306,
3328,
3351,
3372,
3393,
3413,
3432,
3452,
3470,
3488,
3506,
3523,
3539,
3555,
3571,
3586,
3601,
3615,
3628,
3642,
3655,
3667,
3679,
3691,
3702,
3714,
3724,
3735,
3745,
3754,
3764,
3773,
3782,
3791,
3799,
3807,
3815,
3822,
3830,
3837,
3844,
3850,
3857,
3863,
3869,
3875,
3881,
3887,
3892,
3897,
3902,
3907,
3912,
3917,
3921,
3926,
3930,
3934,
3938,
3942,
};  

u16 Temp_Cal(u16 adc)   //返回结果是放大10倍的数值16.9*10=169
{
        u8 j = 0;
        u16 k = 0;
        u16 min;            //当前的位置
        u16 max;            //当前最大的位置
        u16 i;              //温度
        
        adc = 4096- adc;    //得到当前的adc数值
        
        if( adc <Temp_Tab[0])       //温度最小值检测
                return 0xfffe;
        if( adc >Temp_Tab[160])      //温度最大值检测
                return 0xffff;
        
        min = 0;
        max = 160;
        
        for( j=0;j<5;j++ )           //实现五次二分法查询
        {
                k = (min+max)/2;
                if( adc <=Temp_Tab[k])
                        max = k;
                else
                        min = k;
        }
        
        if( adc == Temp_Tab[min])
                i=min*10;
        else if( adc == Temp_Tab[max])
                i=max*10;
        else
        {
            while(min<=max)
                {
                        min++;
                        if(Temp_Tab[min] == adc)
                        {
                                i=min*10;
                                break;
                        }
                        else if(  adc< Temp_Tab[min]  )   //超过这一档的温度的adc
                        {
                                min --;
                                i=Temp_Tab[min];             //上一档的adc数值记下来
                                j=Temp_Tab[min+1]-Temp_Tab[min]; //这2档之间的差值
                                j=(adc-i)*10/j;
                                i=min*10+j;
                                break;
                        }
                }
        }
        return i;
}
复制代码

任务2：使用ADC测量内部1.19V信号源，反推电源电压
截图202503131438581130.jpg

#include "config.h"
#include "task.h"
#include "io.h"
#include "tim.h"
#include "18b20.h"
#include "adc.h"

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

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

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

void main(void)
{
        Sys_init();                                                                                //系统初始化
        usb_init();                                     //USB CDC 接口配置

    IE2 |= 0x80;                                    //使能USB中断
        Timer0_Init();                                                                        //定时器初始化
        Init_595();

        Timer1_Init();
        ADC_Init();
        
    EA = 1;                                                                                        //IE |= 0X80;
        
        P40 = 0;
        
        while (DeviceState != DEVSTATE_CONFIGURED);     //等待USB完成配置

        
        while(1)
        {
                
        if (bUsbOutReady)                                                        //如果接收到了数据
        {
            //USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
                        
            usb_OUT_done();                                                        //
        }
                Task_Pro_Handler_Callback();                                //执行功能函数
                
                SEG_Show_U32((4096*119/(u32)ADC_Read(15)) );

        }
}



void Timer0_Isr(void) interrupt 1                //1MS执行一次
{

        Task_Marks_Handler_Callback();                                        //系统计时

}
复制代码

芯*** · 发表于 2025-3-25 10:13:15

第21集 Flash模拟eeprom，已手敲代码，测试通过
截图202503251010311038.jpg

#include "eeprom.h"

#define         MAIN_Fosc  24000000UL

#define     IAP_STANDBY()   IAP_CMD = 0     //IAP空闲命令（禁止）
#define     IAP_READ()      IAP_CMD = 1     //IAP读出命令
#define     IAP_WRITE()     IAP_CMD = 2     //IAP写入命令
#define     IAP_ERASE()     IAP_CMD = 3     //IAP擦除命令

#define     IAP_ENABLE()    IAP_CONTR = IAP_EN; IAP_TPS = MAIN_Fosc / 1000000
#define     IAP_DISABLE()   IAP_CONTR = 0; IAP_CMD = 0; IAP_TRIG = 0; IAP_ADDRE = 0xff; IAP_ADDRH = 0xff; IAP_ADDRL = 0xff

#define IAP_EN          (1<<7)
#define IAP_SWBS        (1<<6)
#define IAP_SWRST       (1<<5)
#define IAP_CMD_FAIL    (1<<4)


//========================================================================
// 函数: void DisableEEPROM(void)
// 描述: 禁止EEPROM.
// 参数: none.
// 返回: none.
// 版本: V1.0, 2014-6-30
//========================================================================
void DisableEEPROM(void)        //禁止访问EEPROM
{
    IAP_CONTR = 0;          //关闭 IAP 功能
    IAP_CMD = 0;            //清除命令寄存器
    IAP_TRIG = 0;           //清除触发寄存器
    IAP_ADDRE = 0xff;       //将地址设置到非 IAP 区域
    IAP_ADDRH = 0xff;       //将地址设置到非 IAP 区域
    IAP_ADDRL = 0xff;
}

//========================================================================
// 函数: void EEPROM_Trig(void)
// 描述: 触发EEPROM操作.
// 参数: none.
// 返回: none.
// 版本: V1.0, 2014-6-30
//========================================================================
void EEPROM_Trig(void)
{
    F0 = EA;    //保存全局中断
    EA = 0;     //禁止中断, 避免触发命令无效
    IAP_TRIG = 0x5A;
    IAP_TRIG = 0xA5;    //先送5AH，再送A5H到IAP触发寄存器，每次都需要如此
                        //送完A5H后，IAP命令立即被触发启动
                        //CPU等待IAP完成后，才会继续执行程序。
    _nop_();   //多级流水线的指令系统，触发命令后建议加4个NOP，保证IAP_DATA的数据完成准备
    _nop_();
    _nop_();
    _nop_();
    EA = F0;    //恢复全局中断
}

//========================================================================
// 函数: void EEPROM_SectorErase(u32 EE_address)
// 描述: 擦除一个扇区.
// 参数: EE_address:  要擦除的EEPROM的扇区中的一个字节地址.
// 返回: none.
// 版本: V1.0, 2014-6-30
//========================================================================
void EEPROM_SectorErase(u32 EE_address)
{
    IAP_ENABLE();                       //设置等待时间，允许IAP操作，送一次就够
    IAP_ERASE();                        //宏调用, 送扇区擦除命令，命令不需改变时，不需重新送命令
                                        //只有扇区擦除，没有字节擦除，512字节/扇区。
                                        //扇区中任意一个字节地址都是扇区地址。
    IAP_ADDRE = (u8)(EE_address >> 16); //送扇区地址高字节（地址需要改变时才需重新送地址）
    IAP_ADDRH = (u8)(EE_address >> 8);  //送扇区地址中字节（地址需要改变时才需重新送地址）
    IAP_ADDRL = (u8)EE_address;         //送扇区地址低字节（地址需要改变时才需重新送地址）
    EEPROM_Trig();                      //触发EEPROM操作
    DisableEEPROM();                    //禁止EEPROM操作
}

//========================================================================
// 函数: void EEPROM_read_n(u32 EE_address,u8 *DataAddress,u8 lenth)
// 描述: 读N个字节函数.
// 参数: EE_address:  要读出的EEPROM的首地址.
//       DataAddress: 要读出数据的指针.
//       length:      要读出的长度
// 返回: 0: 写入正确.  1: 写入长度为0错误.  2: 写入数据错误.
// 版本: V1.0, 2014-6-30
//========================================================================
void EEPROM_read_n(u32 EE_address,u8 *DataAddress,u8 length)
{
    IAP_ENABLE();                           //设置等待时间，允许IAP操作，送一次就够
    IAP_READ();                             //送字节读命令，命令不需改变时，不需重新送命令
    do
    {
        IAP_ADDRE = (u8)(EE_address >> 16); //送地址高字节（地址需要改变时才需重新送地址）
        IAP_ADDRH = (u8)(EE_address >> 8);  //送地址中字节（地址需要改变时才需重新送地址）
        IAP_ADDRL = (u8)EE_address;         //送地址低字节（地址需要改变时才需重新送地址）
        EEPROM_Trig();                      //触发EEPROM操作
        *DataAddress = IAP_DATA;            //读出的数据送往
        EE_address++;
        DataAddress++;
    }while(--length);

    DisableEEPROM();
}


//========================================================================
// 函数: u8 EEPROM_write_n(u32 EE_address,u8 *DataAddress,u8 length)
// 描述: 写N个字节函数.
// 参数: EE_address:  要写入的EEPROM的首地址.
//       DataAddress: 要写入数据的指针.
//       length:      要写入的长度
// 返回: 0: 写入正确.  1: 写入长度为0错误.  2: 写入数据错误.
// 版本: V1.0, 2014-6-30
//========================================================================
u8 EEPROM_write_n(u32 EE_address,u8 *DataAddress,u8 length)
{
    u8  i;
    u16 j;
    u8  *p;
    
    if(length == 0) return 1;   //长度为0错误

    IAP_ENABLE();                       //设置等待时间，允许IAP操作，送一次就够
    i = length;
    j = EE_address;
    p = DataAddress;
    IAP_WRITE();                            //宏调用, 送字节写命令
    do
    {
        IAP_ADDRE = (u8)(EE_address >> 16); //送地址高字节（地址需要改变时才需重新送地址）
        IAP_ADDRH = (u8)(EE_address >> 8);  //送地址中字节（地址需要改变时才需重新送地址）
        IAP_ADDRL = (u8)EE_address;         //送地址低字节（地址需要改变时才需重新送地址）
        IAP_DATA  = *DataAddress;           //送数据到IAP_DATA，只有数据改变时才需重新送
        EEPROM_Trig();                      //触发EEPROM操作
        EE_address++;                       //下一个地址
        DataAddress++;                      //下一个数据
    }while(--length);                       //直到结束

    EE_address = j;
    length = i;
    DataAddress = p;
    i = 0;
    IAP_READ();                             //读N个字节并比较
    do
    {
        IAP_ADDRE = (u8)(EE_address >> 16); //送地址高字节（地址需要改变时才需重新送地址）
        IAP_ADDRH = (u8)(EE_address >> 8);  //送地址中字节（地址需要改变时才需重新送地址）
        IAP_ADDRL = (u8)EE_address;         //送地址低字节（地址需要改变时才需重新送地址）
        EEPROM_Trig();                      //触发EEPROM操作
        if(*DataAddress != IAP_DATA)        //读出的数据与源数据比较
        {
            i = 2;
            break;
        }
        EE_address++;
        DataAddress++;
    }while(--length);

    DisableEEPROM();
    return i;
}

#define E_ADDR  10
#define E_PWR        0XFE

u8 SYS_Run_times = 0;

//任务1:实现手册的EEPROM的基本操作，并用数码管显示当前的数值。并实现每次重新开机数值+1。
void Parm_Init(void)
{
        u8 dat[5];                        //0:操作码   1：开机次数   2：校验码(累加校验)
        
        EEPROM_read_n( E_ADDR,dat,3 );
        
        if( dat[0] != E_PWR )                        //如果读取到的数据不为操作码，就是第一次上电，此时可以初始化
        {
                EEPROM_SectorErase(E_ADDR);        //清空地址里的数据，擦除扇区
                dat[0] = E_PWR;
                dat[1] = 0;
                dat[2] = (dat[0]+dat[1]);
                EEPROM_write_n(E_ADDR,dat,3);
                
                SYS_Run_times = 0;
        }
        else                                                        //第二次及其之后的上电
        {
                if( dat[2] == (u8)(dat[0]+dat[1]) )        //校验通过，数据有效
                {
                        SYS_Run_times = dat[1];
                        SYS_Run_times +=1;
                        EEPROM_SectorErase(E_ADDR);        //清空地址里的数据，擦除扇区
                        dat[0] = E_PWR;
                        dat[1] = SYS_Run_times;
                        dat[2] = (dat[0]+dat[1]);
                        EEPROM_write_n(E_ADDR,dat,3);                        
                }
                else
                {
                        //如果数据校验出错，执行什么
                }
        }
}
复制代码

		自动登录	找回密码
密码			立即注册