金沙滩单片机第8章练习按键控制LED和数码管和点阵

已于 2022-06-10 09:42:35 修改
阅读量3.1k 收藏 15
点赞数 3
文章标签： 单片机 c语言 嵌入式硬件
于 2022-05-25 01:17:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47454452/article/details/124958340
版权

上键流水灯
左键数码管倒计时
右键点阵
下键全部显示

上键控制流水灯完成
左键控制数码管完成
右键点阵----------------待完成—按键切换已经完成，后续也就不想当缝合怪了，开启通信模块的学习
下键全部显示----------------待完成—按键切换已经完成，后续也就不想当缝合怪了，开启通信模块的学习
突然想到定义4个全局变量四种状态

#include <reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit KEY_IN_1  = P2^4;
sbit KEY_IN_2  = P2^5;
sbit KEY_IN_3  = P2^6;
sbit KEY_IN_4  = P2^7;
sbit KEY_OUT_1 = P2^3;
sbit KEY_OUT_2 = P2^2;
sbit KEY_OUT_3 = P2^1;
sbit KEY_OUT_4 = P2^0;

unsigned char code image[] = {  //图片的字模表
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    0x99,0x99,0x99,0x99,0x99,0x81,0xC3,0xFF, 
    0x99,0x00,0x00,0x00,0x81,0xC3,0xE7,0xFF, 
	0xC3,0xE7,0xE7,0xE7,0xE7,0xE7,0xC3,0xFF, 
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
};

unsigned char code LedChar[] = {  //数码管显示字符转换表
    0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
    0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
};

unsigned char LedBuff[7] = {  //数码管+点阵+流水灯显示缓冲区
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF
};

unsigned char code KeyCodeMap[4][4] = { //矩阵按键编号到标准键盘键码的映射表
    { 0x31, 0x32, 0x33, 0x26 }, //数字键1、数字键2、数字键3、向上键
    { 0x34, 0x35, 0x36, 0x25 }, //数字键4、数字键5、数字键6、向左键
    { 0x37, 0x38, 0x39, 0x28 }, //数字键7、数字键8、数字键9、向下键
    { 0x30, 0x1B, 0x0D, 0x27 }  //数字键0、ESC键、  回车键、 向右键
};
unsigned char KeySta[4][4] = {  //全部矩阵按键的当前状态
    {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}
};
unsigned char i = 0;   //动态扫描的索引
unsigned int cnt = 0;  //记录T0中断次数
unsigned char flag1s = 0;  //1秒定时标志
void WaterLamp();
void KeyDriver();
void DigitalTube();

void main()
{
    EA = 1;       //使能总中断
    //ENLED = 0;    //选择数码管进行显示
    //ADDR3 = 1;
	ENLED = 0;    //使能U3，选择独立LED
    ADDR3 = 1;
	//流水灯
    //ADDR2 = 1;
    //ADDR1 = 1;
    //ADDR0 = 0;
    TMOD = 0x01;  //设置T0为模式1
    TH0  = 0xFC;  //为T0赋初值0xFC67，定时1ms
    TL0  = 0x67;
    ET0  = 1;     //使能T0中断
    TR0  = 1;     //启动T0
    //LedBuff[0] = LedChar[0];  //上电显示0
    
	
    while (1)
    {
        KeyDriver();   //调用按键驱动函数
    }
}

/* 按键动作函数，根据键码执行相应的操作，keycode-按键键码 */
void KeyAction(unsigned char keycode)
{
    //static unsigned long result = 0;  //用于保存运算结果
    //static unsigned long addend = 0;  //用于保存输入的加数
    
    if ((keycode>=0x30) && (keycode<=0x39))  //输入0-9的数字
    {
        //addend = (addend*10)+(keycode-0x30); //整体十进制左移，新数字进入个位
        //ShowNumber(addend);    //运算结果显示到数码管
    }
    else if (keycode == 0x26)  //向上键用作加号，执行加法或连加运算
    {
	    WaterLamp();
        //result += addend;      //进行加法运算
        //addend = 0;
        //ShowNumber(result);    //运算结果显示到数码管
    }
	else if (keycode == 0x25)  //向上键用作加号，执行加法或连加运算
    {
	    DigitalTube();
        //result += addend;      //进行加法运算
        //addend = 0;
        //ShowNumber(result);    //运算结果显示到数码管
    }
    else if (keycode == 0x0D)  //回车键，执行加法运算(实际效果与加号相同)
    {
        //result += addend;      //进行加法运算
        //addend = 0;
        //ShowNumber(result);    //运算结果显示到数码管
    }
    else if (keycode == 0x1B)  //Esc键，清零结果
    {
        //addend = 0;
        //result = 0;
        //ShowNumber(addend);    //清零后的加数显示到数码管
    }
}

void KeyDriver()
{
    unsigned char i, j;
    static unsigned char backup[4][4] = {  //按键值备份，保存前一次的值
        {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}
    };
    
    for (i=0; i<4; i++)  //循环检测4*4的矩阵按键
    {
        for (j=0; j<4; j++)
        {
            if (backup[i][j] != KeySta[i][j])    //检测按键动作
            {
                if (backup[i][j] != 0)           //按键按下时执行动作
                {
                    KeyAction(KeyCodeMap[i][j]); //调用按键动作函数
                }
                backup[i][j] = KeySta[i][j];     //刷新前一次的备份值
            }
        }
    }
}

void DigitalTube()
{
	char j;  //循环变量
	unsigned long sec;	 //记录经过的秒数
    unsigned char buf[6];   //中间转换缓冲区
	unsigned char dir = 0;
	if (dir == 0) {
	    sec = 0;  
	} else {
	    sec = 1000000;
	}
	while (1)
    {
        if (flag1s == 1)  //判断1秒定时标志
        {
            flag1s = 0;   //1秒定时标志清零
			if (dir == 0) {
			    sec++;        //秒计数自加1
				if (sec >= 1000000)        
                {
                    dir = 1;
                }
			} else {
                sec--;
				if (sec < 0)        
                {
                    dir = 1;
                }
			}
            //将sec按十进制位从低到高依次提取到buf数组中
            buf[0] = sec%10;
            buf[1] = sec/10%10;
            buf[2] = sec/100%10;
            buf[3] = sec/1000%10;
            buf[4] = sec/10000%10;
            buf[5] = sec/100000%10;
            //从最高为开始，遇到0不显示，遇到非0退出循环
            for (j=5; j>=0; j--)
            {
                if (buf[j] == 0)
                    LedBuff[j] = 0xFF;
                else
                    break;
            }
            //将剩余的有效数字位如实转换
            for ( ; j>=0; j--)  //for()起始未对j操作，j即保持上个循环结束时的值
            {
                LedBuff[j] = LedChar[buf[j]];
            }
        }
    }
}
void WaterLamp()
{
    static unsigned int cnt = 0;   //定义计数变量cnt，记录T0溢出次数
    static unsigned char dir = 0;   //定义移位方向变量dir，用于控制移位的方向
    static unsigned char shift = 0x01;  //定义循环移位变量shift，并赋初值0x01
    //static unsigned int i = 0;
	ENLED = 0;    //使能U3，选择独立LED
    ADDR3 = 1;
	ADDR2 = 1;
    ADDR1 = 1;
    ADDR0 = 0;
	while(1) 
	{
		P0 = ~shift;       //P0等于循环移位变量取反，控制8个LED
	    if (TF0 == 1) {
        TF0 = 0;           //T0溢出后，清零中断标志
        TH0 = 0xFC;        //并重新赋初值
        TL0 = 0x67;
        cnt++;            //计数值自加1
        if (cnt >= 1000) {     //T0溢出达到10次后，控制移位
            cnt = 0;
            if (dir == 0) {           //移位方向变量为0时，左移
                shift = shift << 1;  //循环移位变量左移1位
                if (shift == 0x80) {  //左移到最左端后，改变移位方向
                    dir = 1;
                }
            } else {   //移位方向变量不为0时，右移               
                shift = shift >> 1;  //循环移位变量右移1位
                if (shift == 0x01) {   //右移到最右端后，改变移位方向
                    dir = 0;
                    }
                }
            }
	    }
	} 
}

void KeyScan()
{
    unsigned char i;
    static unsigned char keyout = 0;   //矩阵按键扫描输出索引
    static unsigned char keybuf[4][4] = {  //矩阵按键扫描缓冲区
        {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF},
        {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF}
    };

    //将一行的4个按键值移入缓冲区
    keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
    keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
    keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
    keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
    //消抖后更新按键状态
    for (i=0; i<4; i++)  //每行4个按键，所以循环4次
    {
        if ((keybuf[keyout][i] & 0x0F) == 0x00)
        {   //连续4次扫描值为0，即4*4ms内都是按下状态时，可认为按键已稳定的按下
            KeySta[keyout][i] = 0;
        }
        else if ((keybuf[keyout][i] & 0x0F) == 0x0F)
        {   //连续4次扫描值为1，即4*4ms内都是弹起状态时，可认为按键已稳定的弹起
            KeySta[keyout][i] = 1;
        }
    }
    //执行下一次的扫描输出
    keyout++;                //输出索引递增
    keyout = keyout & 0x03;  //索引值加到4即归零
    switch (keyout)          //根据索引，释放当前输出引脚，拉低下次的输出引脚
    {
        case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
        case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
        case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
        case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
        default: break;
    }
}

/* T0中断服务函数，用于数码管显示扫描与按键扫描 */
void InterruptTimer0() interrupt 1
{
    TH0 = 0xFC;  //重新加载初值
    TL0 = 0x67;
	cnt++;       //中断次数计数值加1
    if (cnt >= 1000)  //中断1000次即1秒
    {
        cnt = 0;      //清零计数值以重新开始下1秒计时
        flag1s = 1;   //设置1秒定时标志为1
    }
    //以下代码完成数码管动态扫描刷新
    P0 = 0xFF;   //显示消隐
    switch (i)
    {
        case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0]; break;
        case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1]; break;
        case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2]; break;
        case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3]; break;
        case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4]; break;
        case 5: ADDR2=1; ADDR1=0; ADDR0=1; i=0; P0=LedBuff[5]; break;
        default: break;
    }
    //LedScan();   //调用数码管显示扫描函数
    KeyScan();   //调用按键扫描函数
}

/* 定时器0中断服务函数 */
/*
void InterruptTimer0() interrupt 1
{
    static unsigned char i = 0;  //动态扫描的索引
    static unsigned char tmr = 0;  //250ms软件定时器
    static unsigned char index = 32;  //图片刷新索引

    TH0 = 0xFC;  //重新加载初值
    TL0 = 0x67;
    //以下代码完成LED点阵动态扫描刷新
    P0 = 0xFF;   //显示消隐
    switch (i)
    {
        case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=image[index+0]; break;
        case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=image[index+1]; break;
        case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=image[index+2]; break;
        case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=image[index+3]; break;
        case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=image[index+4]; break;
        case 5: ADDR2=1; ADDR1=0; ADDR0=1; i++; P0=image[index+5]; break;
        case 6: ADDR2=1; ADDR1=1; ADDR0=0; i++; P0=image[index+6]; break;
        case 7: ADDR2=1; ADDR1=1; ADDR0=1; i=0; P0=image[index+7]; break;
        default: break;
    }
    //以下代码完成每250ms改变一帧图像
    tmr++;
    if (tmr >= 250)  //达到250ms时改变一次图片索引
    {
        tmr = 0;
        index--;
        if (index <= 0)  //图片索引达到32后归零
        {
            index = 32;
        }
    }
}
*/

上面那个版本没法实现数码管和流水灯的切换
下面这个版本实现了数码管和流水灯的切换但是流水灯和数码管走不起来，主要是while(1)，死循环的问题，下个版本再改进

#include <reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit KEY_IN_1  = P2^4;
sbit KEY_IN_2  = P2^5;
sbit KEY_IN_3  = P2^6;
sbit KEY_IN_4  = P2^7;
sbit KEY_OUT_1 = P2^3;
sbit KEY_OUT_2 = P2^2;
sbit KEY_OUT_3 = P2^1;
sbit KEY_OUT_4 = P2^0;

unsigned char code image[] = {  //图片的字模表
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    0x99,0x99,0x99,0x99,0x99,0x81,0xC3,0xFF, 
    0x99,0x00,0x00,0x00,0x81,0xC3,0xE7,0xFF, 
	0xC3,0xE7,0xE7,0xE7,0xE7,0xE7,0xC3,0xFF, 
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
};

unsigned char code LedChar[] = {  //数码管显示字符转换表
    0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
    0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
};

unsigned char LedBuff[7] = {  //数码管+点阵+流水灯显示缓冲区
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF
};

unsigned char code KeyCodeMap[4][4] = { //矩阵按键编号到标准键盘键码的映射表
    { 0x31, 0x32, 0x33, 0x26 }, //数字键1、数字键2、数字键3、向上键
    { 0x34, 0x35, 0x36, 0x25 }, //数字键4、数字键5、数字键6、向左键
    { 0x37, 0x38, 0x39, 0x28 }, //数字键7、数字键8、数字键9、向下键
    { 0x30, 0x1B, 0x0D, 0x27 }  //数字键0、ESC键、  回车键、 向右键
};
unsigned char KeySta[4][4] = {  //全部矩阵按键的当前状态
    {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}
};
unsigned char i = 0;   //动态扫描的索引
unsigned int cnt = 0;  //记录T0中断次数
unsigned char flag1s = 0;  //1秒定时标志
unsigned char model_1;  //流水灯模式
unsigned char model_2;  //数码管模式  
void WaterLamp();
void KeyDriver();
void DigitalTube();


void main()
{
    EA = 1;       //使能总中断
	ENLED = 0;    //使能U3，选择独立LED
    ADDR3 = 1;
    TMOD = 0x01;  //设置T0为模式1
    TH0  = 0xFC;  //为T0赋初值0xFC67，定时1ms
    TL0  = 0x67;
    ET0  = 1;     //使能T0中断
    TR0  = 1;     //启动T0
    
	
    while (1)
    {
        KeyDriver();   //调用按键驱动函数
    }
}

/* 按键动作函数，根据键码执行相应的操作，keycode-按键键码 */
void KeyAction(unsigned char keycode)
{	
    
    switch (keycode)
	{
	    case 0x26: model_1 = 1; model_2 = 0; WaterLamp(); break;        
		case 0x25: model_2 = 1; model_1 = 0; DigitalTube(); break;
	}
	
    /*
    if ((keycode>=0x30) && (keycode<=0x39))  //输入0-9的数字
    {

    }
    else if (keycode == 0x26)  //向上键用作加号，执行加法或连加运算
    {
	    model_1 = 1;
		model_2 = 0;
		if (model_1) {
		    while(1) {
				WaterLamp();
			}  
		}
    }
	else if (keycode == 0x25)  //向上键用作加号，执行加法或连加运算
    {
	    model_2 = 1;
		model_1 = 0;
		if (model_2) {
	        DigitalTube();
		}
    }
    else if (keycode == 0x0D)  //回车键，执行加法运算(实际效果与加号相同)
    {

    }
    else if (keycode == 0x1B)  //Esc键，清零结果
    {
        
    }
	*/
}

void KeyDriver()
{
    unsigned char i, j;
    static unsigned char backup[4][4] = {  //按键值备份，保存前一次的值
        {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}
    };
    
    for (i=0; i<4; i++)  //循环检测4*4的矩阵按键
    {
        for (j=0; j<4; j++)
        {
            if (backup[i][j] != KeySta[i][j])    //检测按键动作
            {
                if (backup[i][j] != 0)           //按键按下时执行动作
                {
                    KeyAction(KeyCodeMap[i][j]); //调用按键动作函数
                }
                backup[i][j] = KeySta[i][j];     //刷新前一次的备份值
            }
        }
    }
}

void DigitalTube()
{
	char j;  //循环变量
	unsigned long sec;	 //记录经过的秒数
    unsigned char buf[6];   //中间转换缓冲区
	unsigned char dir = 0;
	if (dir == 0) {
	    sec = 0;  
	} else {
	    sec = 1000000;
	}
    if(model_2) 
    {
        if (flag1s == 1)  //判断1秒定时标志
        {
            flag1s = 0;   //1秒定时标志清零
			if (dir == 0) {
			    sec++;        //秒计数自加1
				if (sec >= 1000000)        
                {
                    dir = 1;
                }
			} else {
                sec--;
				if (sec < 0)        
                {
                    dir = 1;
                }
			}
            //将sec按十进制位从低到高依次提取到buf数组中
            buf[0] = sec%10;
            buf[1] = sec/10%10;
            buf[2] = sec/100%10;
            buf[3] = sec/1000%10;
            buf[4] = sec/10000%10;
            buf[5] = sec/100000%10;
            //从最高为开始，遇到0不显示，遇到非0退出循环
            for (j=5; j>=0; j--)
            {
                if (buf[j] == 0)
                    LedBuff[j] = 0xFF;
                else
                    break;
            }
            //将剩余的有效数字位如实转换
            for ( ; j>=0; j--)  //for()起始未对j操作，j即保持上个循环结束时的值
            {
                LedBuff[j] = LedChar[buf[j]];
            }
        }
    }
}
void WaterLamp()
{
    if(model_1) { 
	    static unsigned char dir = 0;   //定义移位方向变量dir，用于控制移位的方向
	    static unsigned char shift = 0x01;  //定义循环移位变量shift，并赋初值0x01
		P0 = ~shift;       //P0等于循环移位变量取反，控制8个LED
		
		if (flag1s == 1)  //判断1秒定时标志
	    {
	        flag1s = 0;   //1秒定时标志清零
		    if (dir == 0) {           //移位方向变量为0时，左移
	        shift = shift << 1;  //循环移位变量左移1位
	        if (shift == 0x80) {  //左移到最左端后，改变移位方向
	            dir = 1;
	        }
	    } else {   //移位方向变量不为0时，右移               
	        shift = shift >> 1;  //循环移位变量右移1位
	        if (shift == 0x01) {   //右移到最右端后，改变移位方向
	            dir = 0;
	            }
	        }	
		}
	}
}

void KeyScan()
{
    unsigned char i;
    static unsigned char keyout = 0;   //矩阵按键扫描输出索引
    static unsigned char keybuf[4][4] = {  //矩阵按键扫描缓冲区
        {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF},
        {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF}
    };

    //将一行的4个按键值移入缓冲区
    keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
    keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
    keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
    keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
    //消抖后更新按键状态
    for (i=0; i<4; i++)  //每行4个按键，所以循环4次
    {
        if ((keybuf[keyout][i] & 0x0F) == 0x00)
        {   //连续4次扫描值为0，即4*4ms内都是按下状态时，可认为按键已稳定的按下
            KeySta[keyout][i] = 0;
        }
        else if ((keybuf[keyout][i] & 0x0F) == 0x0F)
        {   //连续4次扫描值为1，即4*4ms内都是弹起状态时，可认为按键已稳定的弹起
            KeySta[keyout][i] = 1;
        }
    }
    //执行下一次的扫描输出
    keyout++;                //输出索引递增
    keyout = keyout & 0x03;  //索引值加到4即归零
    switch (keyout)          //根据索引，释放当前输出引脚，拉低下次的输出引脚
    {
        case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
        case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
        case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
        case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
        default: break;
    }
}

/* T0中断服务函数，用于数码管显示扫描与按键扫描 */
void InterruptTimer0() interrupt 1
{
    TH0 = 0xFC;  //重新加载初值
    TL0 = 0x67;
	cnt++;       //中断次数计数值加1
    if (cnt >= 1000)  //中断1000次即1秒
    {
        cnt = 0;      //清零计数值以重新开始下1秒计时
        flag1s = 1;   //设置1秒定时标志为1
    }
    //以下代码完成数码管动态扫描刷新
	if (model_1) {
	    ADDR2 = 1;
        ADDR1 = 1;
        ADDR0 = 0;
	}
	if (model_2) {
	    P0 = 0xFF;   //显示消隐
	    switch (i)
	    {
	        case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0]; break;
	        case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1]; break;
	        case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2]; break;
	        case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3]; break;
	        case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4]; break;
	        case 5: ADDR2=1; ADDR1=0; ADDR0=1; i=0; P0=LedBuff[5]; break;
	        default: break;
	    }
	}
    //LedScan();   //调用数码管显示扫描函数
    KeyScan();   //调用按键扫描函数
}

突然想到了return 和break；
应该用return当前函数---------------------失败
解决方法放进主函数里进行循环
这个版本解决了流水灯和数码管的切换效果

#include <reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit KEY_IN_1  = P2^4;
sbit KEY_IN_2  = P2^5;
sbit KEY_IN_3  = P2^6;
sbit KEY_IN_4  = P2^7;
sbit KEY_OUT_1 = P2^3;
sbit KEY_OUT_2 = P2^2;
sbit KEY_OUT_3 = P2^1;
sbit KEY_OUT_4 = P2^0;

unsigned char code image[] = {  //图片的字模表
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    0x99,0x99,0x99,0x99,0x99,0x81,0xC3,0xFF, 
    0x99,0x00,0x00,0x00,0x81,0xC3,0xE7,0xFF, 
	0xC3,0xE7,0xE7,0xE7,0xE7,0xE7,0xC3,0xFF, 
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
};

unsigned char code LedChar[] = {  //数码管显示字符转换表
    0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
    0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
};

unsigned char LedBuff[7] = {  //数码管+点阵+流水灯显示缓冲区
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF
};

unsigned char code KeyCodeMap[4][4] = { //矩阵按键编号到标准键盘键码的映射表
    { 0x31, 0x32, 0x33, 0x26 }, //数字键1、数字键2、数字键3、向上键
    { 0x34, 0x35, 0x36, 0x25 }, //数字键4、数字键5、数字键6、向左键
    { 0x37, 0x38, 0x39, 0x28 }, //数字键7、数字键8、数字键9、向下键
    { 0x30, 0x1B, 0x0D, 0x27 }  //数字键0、ESC键、  回车键、 向右键
};
unsigned char KeySta[4][4] = {  //全部矩阵按键的当前状态
    {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}
};
unsigned char i = 0;   //动态扫描的索引
unsigned int cnt = 0;  //记录T0中断次数
unsigned char flag1s = 0;  //1秒定时标志
unsigned char model_1;  //流水灯模式
unsigned char model_2;  //数码管模式 
unsigned char model_3;  //数码管模式  
void WaterLamp();
void KeyDriver();
void DigitalTube();

//static char j;  //循环变量
static unsigned long sec;	 //记录经过的秒数
//static unsigned char buf[6];   //中间转换缓冲区
static unsigned char dir = 0;


void main()
{
    EA = 1;       //使能总中断
	ENLED = 0;    //使能U3，选择独立LED
    ADDR3 = 1;
    TMOD = 0x01;  //设置T0为模式1
    TH0  = 0xFC;  //为T0赋初值0xFC67，定时1ms
    TL0  = 0x67;
    ET0  = 1;     //使能T0中断
    TR0  = 1;     //启动T0
    if (dir == 0) {
	    sec = 0;  
	} else {
	    sec = 1000000;
	}
	
    while (1)
    {
	    
        KeyDriver();   //调用按键驱动函数
		if (model_1) 
		{
		    WaterLamp();
		} else {
		/*
		    if (dir == 0) {
			    sec++;        //秒计数自加1
				if (sec >= 1000000)        
                {
                    dir = 1;
                }
			} else {
                sec--;
				if (sec < 0)        
                {
                    dir = 1;
                }
			}
		*/
		    DigitalTube();
		}
    }
}

/* 按键动作函数，根据键码执行相应的操作，keycode-按键键码 */
void KeyAction(unsigned char keycode)
{	
    switch (keycode)
	{
	    case 0x26: model_1 = 1; 
		           model_2 = 0;
				   break;        
		case 0x25: model_2 = 1; 
		           model_1 = 0; 
				   break;
	}
	
    /*
    if ((keycode>=0x30) && (keycode<=0x39))  //输入0-9的数字
    {

    }
    else if (keycode == 0x26)  //向上键用作加号，执行加法或连加运算
    {
	    model_1 = 1;
		model_2 = 0;
		if (model_1) {
		    while(1) {
				WaterLamp();
			}  
		}
    }
	else if (keycode == 0x25)  //向上键用作加号，执行加法或连加运算
    {
	    model_2 = 1;
		model_1 = 0;
		if (model_2) {
	        DigitalTube();
		}
    }
    else if (keycode == 0x0D)  //回车键，执行加法运算(实际效果与加号相同)
    {

    }
    else if (keycode == 0x1B)  //Esc键，清零结果
    {
        
    }
	*/
}

void KeyDriver()
{
    unsigned char i, j;
    static unsigned char backup[4][4] = {  //按键值备份，保存前一次的值
        {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}
    };
    
    for (i=0; i<4; i++)  //循环检测4*4的矩阵按键
    {
        for (j=0; j<4; j++)
        {
            if (backup[i][j] != KeySta[i][j])    //检测按键动作
            {
                if (backup[i][j] != 0)           //按键按下时执行动作
                {
                    KeyAction(KeyCodeMap[i][j]); //调用按键动作函数
                }
                backup[i][j] = KeySta[i][j];     //刷新前一次的备份值
            }
        }
    }
}

void DigitalTube()
{
	static char j;  //循环变量
	//unsigned long sec;	 //记录经过的秒数
    static unsigned char buf[6];   //中间转换缓冲区
	//unsigned char dir = 0;
	/*
	if (dir == 0) {
	    sec = 0;  
	} else {
	    sec = 1000000;
	}
	*/
	
        if (flag1s == 1)  //判断1秒定时标志
        {
            flag1s = 0;   //1秒定时标志清零
			if (dir == 0) {
			    sec++;        //秒计数自加1
				if (sec >= 1000000)        
                {
                    dir = 1;
                }
			} else {
                sec--;
				if (sec < 0)        
                {
                    dir = 1;
                }
			}
			
            //将sec按十进制位从低到高依次提取到buf数组中
            buf[0] = sec%10;
            buf[1] = sec/10%10;
            buf[2] = sec/100%10;
            buf[3] = sec/1000%10;
            buf[4] = sec/10000%10;
            buf[5] = sec/100000%10;
            //从最高为开始，遇到0不显示，遇到非0退出循环
            for (j=5; j>=0; j--)
            {
                if (buf[j] == 0)
                    LedBuff[j] = 0xFF;
                else
                    break;
            }
            //将剩余的有效数字位如实转换
            for ( ; j>=0; j--)  //for()起始未对j操作，j即保持上个循环结束时的值
            {
                LedBuff[j] = LedChar[buf[j]];
            }
        }
}
void WaterLamp()
{
	    static unsigned char dir = 0;   //定义移位方向变量dir，用于控制移位的方向
	    static unsigned char shift = 0x01;  //定义循环移位变量shift，并赋初值0x01
		P0 = ~shift;       //P0等于循环移位变量取反，控制8个LED
	
		if (flag1s == 1)  //判断1秒定时标志
	    {
	        flag1s = 0;   //1秒定时标志清零
		    if (dir == 0) {           //移位方向变量为0时，左移
	        shift = shift << 1;  //循环移位变量左移1位
	        if (shift == 0x80) {  //左移到最左端后，改变移位方向
	            dir = 1;
	        }
	    } else {   //移位方向变量不为0时，右移               
	        shift = shift >> 1;  //循环移位变量右移1位
	        if (shift == 0x01) {   //右移到最右端后，改变移位方向
	            dir = 0;
	            }
	        }	
		}
}

void KeyScan()
{
    unsigned char i;
    static unsigned char keyout = 0;   //矩阵按键扫描输出索引
    static unsigned char keybuf[4][4] = {  //矩阵按键扫描缓冲区
        {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF},
        {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF}
    };

    //将一行的4个按键值移入缓冲区
    keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
    keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
    keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
    keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
    //消抖后更新按键状态
    for (i=0; i<4; i++)  //每行4个按键，所以循环4次
    {
        if ((keybuf[keyout][i] & 0x0F) == 0x00)
        {   //连续4次扫描值为0，即4*4ms内都是按下状态时，可认为按键已稳定的按下
            KeySta[keyout][i] = 0;
        }
        else if ((keybuf[keyout][i] & 0x0F) == 0x0F)
        {   //连续4次扫描值为1，即4*4ms内都是弹起状态时，可认为按键已稳定的弹起
            KeySta[keyout][i] = 1;
        }
    }
    //执行下一次的扫描输出
    keyout++;                //输出索引递增
    keyout = keyout & 0x03;  //索引值加到4即归零
    switch (keyout)          //根据索引，释放当前输出引脚，拉低下次的输出引脚
    {
        case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
        case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
        case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
        case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
        default: break;
    }
}

/* T0中断服务函数，用于数码管显示扫描与按键扫描 */
void InterruptTimer0() interrupt 1
{
    TH0 = 0xFC;  //重新加载初值
    TL0 = 0x67;
	cnt++;       //中断次数计数值加1
    if (cnt >= 1000)  //中断1000次即1秒
    {
        cnt = 0;      //清零计数值以重新开始下1秒计时
        flag1s = 1;   //设置1秒定时标志为1
    }
    //以下代码完成数码管动态扫描刷新
	if (model_1) {
	    ADDR2 = 1;
        ADDR1 = 1;
        ADDR0 = 0;
	}
	if (model_2) {
	    P0 = 0xFF;   //显示消隐
	    switch (i)
	    {
	        case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0]; break;
	        case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1]; break;
	        case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2]; break;
	        case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3]; break;
	        case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4]; break;
	        case 5: ADDR2=1; ADDR1=0; ADDR0=1; i=0; P0=LedBuff[5]; break;
	        default: break;
	    }
	}
    //LedScan();   //调用数码管显示扫描函数
    KeyScan();   //调用按键扫描函数
}

/* 定时器0中断服务函数 */
/*
void InterruptTimer0() interrupt 1
{
    static unsigned char i = 0;  //动态扫描的索引
    static unsigned char tmr = 0;  //250ms软件定时器
    static unsigned char index = 32;  //图片刷新索引

    TH0 = 0xFC;  //重新加载初值
    TL0 = 0x67;
    //以下代码完成LED点阵动态扫描刷新
    P0 = 0xFF;   //显示消隐
    switch (i)
    {
        case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=image[index+0]; break;
        case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=image[index+1]; break;
        case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=image[index+2]; break;
        case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=image[index+3]; break;
        case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=image[index+4]; break;
        case 5: ADDR2=1; ADDR1=0; ADDR0=1; i++; P0=image[index+5]; break;
        case 6: ADDR2=1; ADDR1=1; ADDR0=0; i++; P0=image[index+6]; break;
        case 7: ADDR2=1; ADDR1=1; ADDR0=1; i=0; P0=image[index+7]; break;
        default: break;
    }
    //以下代码完成每250ms改变一帧图像
    tmr++;
    if (tmr >= 250)  //达到250ms时改变一次图片索引
    {
        tmr = 0;
        index--;
        if (index <= 0)  //图片索引达到32后归零
        {
            index = 32;
        }
    }
}
*/
乌拉_乌拉_乌拉
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
金沙滩51单片机开发.zip
07-20
基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例 基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例 基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例 基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例 基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例基于51单片机开发的小程序，学习资料，用于学习51单片机的嵌入式开发，应用案例
单片机 按键控制8×8LED点阵屏显示图形
02-06
单片机按键控制8×8LED点阵屏显示图形
普中51单片机教程-8.LED点阵屏
m0_68839913的博客
02-18 1284
本文介绍普中51单片机的有关LED点阵屏的相关知识，以及一些具体的应用示例
51单片机（金沙滩）
lihuibear的博客
03-14 1392
单片机，英文Micro Controller Unit，简称MCU内部集成了CPU、RAM、ROM、定时器、中断系统、通讯接口等一系列电脑的常用硬件功能单片机的任务是信息采集 (依靠传感器)、处理 (依靠CPU) 和硬件设备 (例如电机，LED等) 的控制单片机跟计算机相比，单片机算是一个袖珍版计算机，一个芯片就能构成完整的计算机系统。但在性能上，与计算机相差甚远，但单片机成本低、体积小、结构简单，在生活和工业控制领域大有所用同时，学习使用单片机是了解计算机原理与结构的最佳选择。
金沙滩51单片机 ——点阵倒计时
weixin_63472329的博客
03-29 2455
让点阵led实现0~9的倒计时 （翻页而不是滑动） #include<reg52.h> sbit ADDR0 = P1^0; sbit ADDR1 = P1^1; sbit ADDR2 = P1^2; sbit ADDR3 = P1^3; sbit ENLED = P1^4; unsigned char code image[10][8]= { {0xFF,0xE7,0xDB,0xDB,0xDB,0xDB,0xE7,0xFF}, {0xFF,0xE3,0xE7,0xE7,0xE7.
51汇编：LED点阵与键盘按键------2019年寒假休息在家看书
痛苦的时候装出幸福相，这不是那么难做到的事
04-03 2743
吐槽 用C51控制这两个内容都挺简单，用汇编的话。。。。。也一样吧。 让LED点阵显示0 检测键盘按键 按键控制LED点阵
51单片机—LED点阵屏学习（普中开发板）
purple_xiaohan的博客
03-11 1079
对于LED 点阵屏原理的理解
一周学完51单片机（2）数码管显示和LED点阵实验
qqp1455755691的博客
03-24 642
SER引脚是数据的输入口，数据高位先进，当在SCLK高电平时，SER数据在数据移位寄存器中往下压一个位置，如此重复8次就将一个字节的数据写入的数据移位寄存器，之后给RCLK一个高电平，移位寄存器中的数据就全部搬运到数据存储器中了，数据存储器是直接和单片机的8个io口相连接的，就可以实现点阵的行控制。LED点阵是由8x8个led组成，和数码管类似，给他们高低电平就可以点亮一个led，通过多种led点亮的组合来实现在led点阵上显示我们所需要的数据。数据首先是存储在数据移位寄存器中之后再搬到数据存储器中的。
按键控制8×8LED点阵屏显示图形
11-17
按键控制8×8LED点阵屏显示图形
野火stm32mini第四章----------------金沙滩单片机上面的数码管
weixin_47454452的博客
10-13 360
stm32mini控制金沙滩51单片机上面的一个数码管
按键控制8×8LED点阵屏显示图形proteus仿真
11-18
基于51单片机的按键控制8×8LED点阵屏显示图形，有Proteus仿真，给初学单片机的同学参考。
单片机C语言程序设计：按键控制 8X8LED 点阵屏显示图形
08-28
名称：按键控制 8X8LED 点阵屏显示图形 说明：每次按下 K1 时，会使 8X8LED点阵屏循环显示不同图形。本例同时使用外部中断和定时中断。
单片机c语言源程序（51定时器 八个按键控制八个LED 单按键控制数码管加1 点亮P0口所有LED 流水灯暗点流动 流水灯亮点流动 闪烁P0口所有LED 数码管动态扫描加1 数码管动态扫描显示 数组流水灯 双按键控制数码管加减1）
05-04
51定时器 八个按键控制八个LED 单按键控制数码管加1 点亮P0口所有LED 流水灯暗点流动 流水灯亮点流动 闪烁P0口所有LED 数码管动态扫描加1 数码管动态扫描显示 数组流水灯 双按键控制数码管加减1
为金沙滩学习板写的数码管操作函数（操作数码管变得轻轻松松）
09-30
每个功能都是用2个文件写的，方便移值，学会这种写法，新手少走很多弯路 方便移植的好处就是---辛苦一次，一劳永逸 把对数码管显示的各个功能都写成了函数，使控制数码管变得很轻松。ShowNumber(123456);//数码管显示函数，数码管显示123456 setdp(6);//x范围0-6，设置点亮小数点,为6时第6位数码管小数点点亮 setsanshuo(6);//x范围0-6，设置数码管闪烁,为6时第6位数码管闪烁 setdisplay(1,1);//自定义哪位数码管显示什么数字,x取值范围为1-6，不在此范围的都归1，Y范围取值范围为0-9，不在此范围都归为0，（1，1）时，第1位数码管显示1 setdisplay(2,2);//自定义哪位数码管显示什么数字,x取值范围为1-6，不在此范围的都归1，Y范围取值范围为0-9，不在此范围都归为0，（2，2）时，第2位数码管显示2 setdisplay(3,3);//自定义哪位数码管显示什么数字,x取值范围为1-6，不在此范围的都归1，Y范围取值范围为0-9，不在此范围都归为0,（3，3）时，第3位数码管显示3 setdisplay(4,4);//自定义哪位数码管显示什么数字,x取值范围为1-6，不在此范围的都归1，Y范围取值范围为0-9，不在此范围都归为0,（4，4）时，第4位数码管显示4 setdisplay(5,5);//自定义哪位数码管显示什么数字,x取值范围为1-6，不在此范围的都归1，Y范围取值范围为0-9，不在此范围都归为0,（5，5）时，第5位数码管显示5 setdisplay(6,6);//自定义哪位数码管显示什么数字,x取值范围为1-6，不在此范围的都归1，Y范围取值范围为0-9，不在此范围都归为0,（6，6）时，第6位数码管显示6
点阵屏坐标显示写贪吃蛇基础（代码基于金沙滩学习板）
10-03
每个功能都是用2个文件写的，方便移值，学会这种写法，新手少走很多弯路 方便移植的好处就是---辛苦一次，一劳永逸 点阵屏坐标显示写贪吃蛇基础（代码基于金沙滩学习板） 掌握了坐标来控制显示，写贪吃蛇游戏就容易了
金沙滩51单片机原理图
03-07
原理图，写单片机程序时使用。
基于金沙滩51单片机的贪吃蛇小游戏
最新发布
05-09
【作品名称】：基于金沙滩51单片机的贪吃蛇小游戏 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： 游戏说明：上下左右...
【制作】基于金沙滩51单片机的贪吃蛇程序
Minuhy
11-18 2722
【制作】基于金沙滩51单片机的贪吃蛇程序 零、起因 要离开实验室了，但是还是有点不放心学弟们的学习，为了让他们知道单片机能干嘛，体会到单片机的快乐，特意作此程序，以提高他们对单片机的学习兴趣。 要实现以下功能： 食物根据随机种子的不同出现的序列也不同 经典贪吃蛇游戏，能穿墙 贪吃蛇速度随分数加快，分数越高，贪吃蛇速度越快 能显示分数 一、电路原理图 用的是金沙滩的51单片机开发板，同款的电路应该是一致的，这部分可略过。 单片机最小系统部分 跳线部分 这部分连的都是ADDR。 数码管、LED部分 这部
金沙滩51单片机60秒数码管倒计时
05-25
实现该功能需要以下步骤： 1. 接线：将数码管的阳极接到单片机的P0口，将8个阴极接到P1~P8口。 2. 初始化：设置P0口为输出，P1~P8口为输入，同时设置定时器1的计时器初值为65536-12000，即每1ms中断一次。 3. 倒计时：在定时器1中断函数中，每1ms更新计时器计数值，同时判断是否到达1秒，如果到达1秒，则将秒数减1，并更新数码管显示。 4. 显示：将秒数转换为BCD码，分别存储在P1~P4口中，然后依次输出到数码管。 以下是代码实现： ``` #include <reg51.h> #define uint unsigned int #define uchar unsigned char sbit dula = P2^6; sbit wela = P2^7; uchar code table[]={ 0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f }; uint count = 60000; // 倒计时60秒 void delay_ms(uint xms) // 延时函数 { uint i,j; for(i = xms;i > 0;i--) for(j = 110;j > 0;j--); } void display(uchar num) // 显示函数 { P1 = table[num/1000]; P2 = 0xfe; delay_ms(1); P2 = 0xff; P1 = table[num%1000/100]; P2 = 0xfd; delay_ms(1); P2 = 0xff; P1 = table[num%100/10]; P2 = 0xfb; delay_ms(1); P2 = 0xff; P1 = table[num%10]; P2 = 0xf7; delay_ms(1); P2 = 0xff; } void timer1() interrupt 3 // 定时器1中断函数 { TH1 = (65536-12000)/256; TL1 = (65536-12000)%256; count--; if(count == 0) // 到达1秒，减1秒 { count = 60000; display(count/1000); // 显示秒数 } } void main() { TMOD = 0x10; // 定时器1工作在方式1 TH1 = (65536-12000)/256; TL1 = (65536-12000)%256; ET1 = 1; // 打开定时器1中断 EA = 1; // 打开总中断 TR1 = 1; // 启动定时器1 P0 = 0x00; P1 = 0x00; P2 = 0xff; P3 = 0xff; P4 = 0xff; while(1) { dula = 1; P0 = 0x00; dula = 0; wela = 1; P0 = 0x7f; wela = 0; } } ``` 需要注意的是，这里使用了定时器1中断来实现每1秒减1秒的倒计时，同时更新数码管显示。数码管的显示函数中，使用了延时函数来控制显示时间。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值