吴鉴鹰51单片机学习—中断、定时器同时点亮数码管和LED各种效果

最新推荐文章于 2024-05-07 16:03:09 发布
最新推荐文章于 2024-05-07 16:03:09 发布
阅读量1.8k 收藏 6
点赞数 2
分类专栏： 单片机 文章标签： 吴鉴鹰 51单片机 单片机学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love_bb/article/details/114377527
版权

LED闪烁有5种效果，数码管点亮有3种效果，包含小彩蛋哟

实现代码如下：

//#include <reg52.h>
#include <REGX52.H>

//typedef unsigned char uchar;
#define uchar unsigned char

sbit HC595_RCK = P0^6;
sbit HC595_SCK = P0^5;
sbit HC595_DATA = P0^7;

uchar LED_1_ARRAY[2] = {0x00, 0x00};

//点亮LED
void send_data(uchar l_one, uchar l_two)
{
    uchar i;
    HC595_RCK = 0;
    for(i = 0; i < 8; i++)
    {
        HC595_SCK = 0;
        HC595_DATA = l_one & 0x80? 1 : 0;
        l_one = l_one << 1;
        HC595_SCK = 1;
    }
    for(i = 0; i < 8; i++)
    {
        HC595_SCK = 0;
        HC595_DATA = l_two & 0x80? 1 : 0;
        l_two = l_two << 1;
        HC595_SCK = 1;
    }
    HC595_RCK = 1;
}

//led 效果1
code uchar Led8_One_Array[16] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
code uchar Led8_Two_Array[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};

//led 效果2
code unsigned char Led8_One2_Array[16] = {0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
code unsigned char Led8_Two2_Array[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF};

//led 效果4
code unsigned char Led8_One4_Array[16] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
code unsigned char Led8_Two4_Array[16] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};

//led 效果5
code unsigned char Led8_One5_Array[17] = {0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF, 0xFF, 0x7F, 0x3F, 0x1F, 0x0F, 0x07, 0x03, 0x01, 0x00};
code unsigned char Led8_Two5_Array[17] = {0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE, 0xFF, 0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0x00};

sbit HC595_RCK2 = P1^0;
sbit HC595_SCK2 = P1^1;
sbit HC595_DATA2 = P1^4;

code uchar SM_Array[11] = {0x3F, 0x06, 0x5B, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7F, 0x6F, 0x00};
code uchar SHU_Wei_Array[8] = {0xFE, 0xFD, 0xFB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F};

//数码管 520效果
code unsigned char SHU_Duan2_Array[8] = {0, 5, 2, 0, 1, 3, 1, 4};

//数码管显数
void Shu_Show_Data(uchar Data_One, uchar Data_Two)
{
    uchar i;
    HC595_RCK2 = 0;
    for(i = 0; i < 8; i++)
    {
        HC595_SCK2 = 0;
        HC595_DATA2 = Data_One & 0x80? 1 : 0;
        Data_One = Data_One << 1;
        HC595_SCK2 = 1;
    }
    for(i = 0; i < 8; i++)
    {
        HC595_SCK2 = 0;
        HC595_DATA2 = Data_Two & 0x80? 1 : 0;
        Data_Two = Data_Two << 1;
        HC595_SCK2 = 1;
    }
    HC595_RCK2 = 1;
}

void time0_init()
{
    TMOD = 0x01;  //设置 T0 为模式 1
    TH0 = 0xFC;  //为 T0 赋初值 0xFC67，定时 1ms
    TL0 = 0x66;
    TR0 = 1;
    
    EA = 1;  //使能总中断
    ET0 = 1;  //使能 T0 中断
}

unsigned int cnt = 0, cnt2 = 1, sec = 0;  //记录 T0 中断次数

uchar led_p_type = 1;//led效果，共5种
uchar led_run_c = 0;//led运行次数
char led_i = 0;//led内部计数
uchar led_giv = 0;//led公共计数变量

uchar shu_sec_array[8] = {0x00};
uchar shu_p_type = 1;//数码管效果，共4种
uchar shu_run_c = 0;//数码管运行次数
char shu_i = 0;//数码管内部计数
uchar shu_giv = 0;//数码管公共计数变量
uchar ii;//数码管循环变量
uchar iii = 0;//数码管延时大循环
uchar iiii = 0;//数码管延时大循环2

void main()
{

    time0_init();
    while(1)
    {
        if(cnt == 200)//0.2s
        {
            cnt = 0;
            switch(shu_p_type) {
                case 1:
                    if(iiii == 0) {
                        shu_giv = shu_i % 8;
                        for(ii = 0; ii < 8; ii++) {
                            if(ii == shu_giv) {
                                shu_sec_array[ii] = iii;
                            } else {
                                shu_sec_array[ii] = 10;
                            }
                        }
                        if(shu_giv == 7) {
                            shu_run_c ++;
                            shu_i = 0;
                            if(shu_run_c == 2) {
                                shu_run_c = 0;
                                shu_p_type ++;
                                shu_giv = 0;
                                iii = 0;
                                iiii = 0;
                                break;
                            }
                        }
                        iii ++;
                        if(iii == 10) {
                            shu_i ++;
                            iii = 0;
                        }
                    }
                    iiii ++;
                    if(iiii == 2) iiii = 0;
                break;
                case 2:
                    if(iii == 0) {
                        shu_giv = shu_i % 10;
                        for(ii = 0; ii < 8; ii++)
                            shu_sec_array[ii] = shu_giv;
                        shu_i ++;
                        if(shu_giv == 9) {
                            shu_run_c ++;
                            shu_i = 0;
                            if(shu_run_c == 2) {
                                shu_run_c = 0;
                                shu_p_type ++;
                                shu_giv = 0;
                                iii = 0;
                                break;
                            }
                        }
                    }
                    iii ++;
                    if(iii == 2) iii = 0;
                break;
                case 3:
                    for(ii = 0; ii < 8; ii++)
                        shu_sec_array[ii] = SHU_Duan2_Array[ii];
                    if(shu_i % 8 == 7) {
                        shu_run_c ++;
                        shu_i = 0;
                        if(shu_run_c == 3) {
                            shu_run_c = 0;
                            shu_p_type ++;
                            shu_giv = 0;
                            break;
                        }
                    }
                    shu_i ++;
                break;
                case 4:
                    sec ++;
                    shu_sec_array[7] = sec / 1 % 10;
                    shu_sec_array[6] = sec / 10 % 10;
                    shu_sec_array[5] = sec / 100 % 10;
                    shu_sec_array[4] = sec / 1000 % 10;
                    shu_sec_array[3] = sec / 10000 % 10;
                    shu_sec_array[2] = sec / 100000 % 10;
                    shu_sec_array[1] = sec / 1000000 % 10;
                    shu_sec_array[0] = sec / 10000000 % 10;
                break;
            }
        }

        if(cnt2 == 300) {//0.3s
            cnt2 = 0;
            switch(led_p_type) {
                case 1:
                    led_giv = led_i % 32;
                    if(led_giv < 16) {
                        LED_1_ARRAY[0] = Led8_One_Array[led_giv];
                        LED_1_ARRAY[1] = Led8_Two_Array[led_giv];
                    } else {
                        LED_1_ARRAY[0] = Led8_One_Array[31 - led_giv];
                        LED_1_ARRAY[1] = Led8_Two_Array[31 - led_giv];
                    }
                    led_i ++;
                    if(led_i == 32) {
                        led_run_c ++;
                        led_i = 0;
                        if(led_run_c == 2) {
                            LED_1_ARRAY[0] = Led8_Two2_Array[0];
                            LED_1_ARRAY[1] = Led8_Two2_Array[0];
                            led_run_c = 0;
                            led_p_type ++;
                            led_giv = 0;
                            break;
                        }
                    }
                break;
                case 2:
                    led_giv = led_i % 16;
                    LED_1_ARRAY[0] = Led8_One2_Array[led_giv];
                    LED_1_ARRAY[1] = Led8_Two2_Array[led_giv];
                    led_i ++;
                    if(led_i == 16) {
                        led_run_c ++;
                        led_i = 0;
                        if(led_run_c == 3) {
                            LED_1_ARRAY[0] = Led8_Two2_Array[0];
                            LED_1_ARRAY[1] = Led8_Two2_Array[0];
                            led_run_c = 0;
                            led_p_type ++;
                            led_giv = 0;
                            break;
                        }
                    }
                break;
                case 3:
                    if(led_i % 2 == 0) {
                        LED_1_ARRAY[0] = Led8_Two2_Array[15];
                        LED_1_ARRAY[1] = Led8_Two2_Array[15];
                    } else {
                        LED_1_ARRAY[0] = Led8_Two2_Array[0];
                        LED_1_ARRAY[1] = Led8_Two2_Array[0];
                    }
                    led_i ++;
                    if(led_i == 2) {
                        led_run_c ++;
                        led_i = 0;
                        if(led_run_c == 6) {
                            LED_1_ARRAY[0] = Led8_Two2_Array[0];
                            LED_1_ARRAY[1] = Led8_Two2_Array[0];
                            led_run_c = 0;
                            led_p_type ++;
                            led_giv = 0;
                            break;
                        }
                    }
                break;
                case 4:
                    led_giv = led_i % 16;
                    LED_1_ARRAY[0] = Led8_One4_Array[led_giv];
                    LED_1_ARRAY[1] = Led8_Two4_Array[led_giv];
                    led_i ++;
                    if(led_i == 16) {
                        led_run_c ++;
                        led_i = 0;
                        if(led_run_c == 3) {
                            LED_1_ARRAY[0] = Led8_Two2_Array[0];
                            LED_1_ARRAY[1] = Led8_Two2_Array[0];
                            led_run_c = 0;
                            led_p_type ++;
                            led_giv = 0;
                            break;
                        }
                    }
                break;
                case 5:
                    led_giv = led_i % 17;
                    LED_1_ARRAY[0] = Led8_One5_Array[led_giv];
                    LED_1_ARRAY[1] = Led8_Two5_Array[led_giv];
                    led_i ++;
                    if(led_i == 17) {
                        led_run_c ++;
                        led_i = 0;
                        if(led_run_c == 3) {
                            LED_1_ARRAY[0] = Led8_Two2_Array[0];
                            LED_1_ARRAY[1] = Led8_Two2_Array[0];
                            led_run_c = 0;
                            led_p_type = 1;
                            led_giv = 0;
                            break;
                        }
                    }
                break;
            }
        }
    }
}

uchar p = 0;

/* 定时器 0 中断服务函数 */
void InterruptTimer0() interrupt 1{
    TH0 = 0xFC;  //重新加载初值
    TL0 = 0x66;
    cnt++;  //中断次数计数值加 1
    cnt2++;

    Shu_Show_Data(SM_Array[shu_sec_array[p]], SHU_Wei_Array[p++]);
    if(p == 8) p = 0;
    
    send_data(LED_1_ARRAY[0], LED_1_ARRAY[1]);

}

 

apples_kk
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
蓝桥杯单片机数码管和LED冲突解决
05-12
STC15f2k61s2 这是一种非常稳定实用的蓝桥杯数码管函数写法 在定时器2~12ms 一次的频率 刷新都无问题 消除了数码管鬼影，亮度较大比较明显，并且还能同时点亮LED，解决了LED与数码管冲突问题，用的定时器刷新数码管LED的思想。
51单片机定时器控制数码管与led共同闪烁
weixin_43394725的博客
02-13 8203
外接晶振为12MHz时，51单片机相关周期的具体值为： 振荡周期=1/12us; 状态周期=1/6us; 机器周期=1us; 指令周期=1~4us; 51单片机定时/计数器的工作由两个特殊功能寄存器控制。TMOD用于设置其工作方式；TCON用于控制其启动和中断申请。 1、工作方式寄存器TMOD 工作方式寄存器TMOD用于设置定时/计数器的工作方式，低四位用于T0，高四位用于T1。其格式如下： G...
初学51单片机点阵LED，数码管，流水灯同时工作的程序实现
最新发布
firewood2024的博客
05-07 800
两句三八译码器从U3切换到U4了，这时点阵LED上的就会显示图象，显示的图像就由前个中断刷新语句ADDR2=0;程序已经实现了三个模块的同时工作，该篇的程序前文都有放出，笔者只是把各个功能模块整合在了一起，在实现这个程序的时候笔者遇到了一个问题导致了鬼影的产生。之前的博文都是放在刷新语句的前面了，现在是放在中断函数里ADDR3和ENLED的前面，因为这两句是切换38译码器U3和U4的语句，举个例子：上图是定时器0的中断函数程序，假设在进入该中断前已经执行了中断1的刷新语句的case3语句，
吴鉴鹰单片机项目实战精讲
07-15
从零开始学习单片机+吴鉴鹰单片机项目实战精讲，从单片机开始学习智能车。俄罗斯方块等游戏，原理源码
吴鉴鹰单片机项目实战精讲汇总.rar
04-05
吴鉴鹰老师的单片机项目实战资料 有详尽的模块介绍 思路梳理，比较遗憾的是代码没有详细注释讲解
51单片机定时器控制数码管与led共同闪烁.rar
07-16
51单片机定时器控制数码管与led共同闪烁.rar
金沙滩51单片机数码、LED、点阵
m0_47329175的博客
12-19 2308
图1 一、数码管与LED 由上面三个图可得知六个数码管与八个LED一起受到U3(74HC138)的控制。 当我们让六个数码管同时亮时，采取的是动态扫描，即1ms进入一次中断进行扫描IO口，又因为一个数码管是由八个LED组成，所以要想数码管和LED同时亮，先用一个数组来暂存LED0~LED7的地址（unsigned char code Led[] = {0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F}），再用一个来暂存数码管的显示数值地址，同时扩大数码...
入门必做的51单片机实验2----》利用外部中断的方法来控制发光二极管和共阴极数码管显示十六进制的0到F
m0_62262008的博客
04-26 3196
嘿！各位中午好！ 我是肖肖的猪会飞 欢迎收看肖小猪频道 刚刚做了个单片机实验—》ヽ(￣ω￣(￣ω￣〃)ゝ 分享一下 文章目录前言一，实验题目二，程序三，仿真效果 前言 此实验为51单片机入门实验，希望对喜欢单片机的小朋友有帮助ヾ(≧ ▽ ≦)ゝ 一，实验题目 按键K1和K2分别节P3.2和P3.3引脚，发光二极管D1接P0.4，共阴极数码管LED接P2口，要求编写程序实现的功能： （1）启动后D1熄灭，LED显示0； （2）单击K1，使得D1灯亮灭状态反转； （3）单击K2，使得LED显示的值加1，并按
51单片机汇编语言定时器数码管
05-12
通过在PROTEUS中仿真，可以直观地看到定时器工作和数码管显示的效果，这对于学习和调试非常有帮助。 综上所述，这个项目涉及了51单片机的定时器操作、数码管显示技术以及使用汇编语言编程。通过学习和实践，我们...
定时器控制数码管动管显示_单片机_Ｃ５１_定时器_数码管_51单片机_
10-02
总的来说，51单片机定时器控制数码管动态显示是单片机应用中的基本技能，涉及到硬件接口设计、中断处理和优化算法等多个方面。通过掌握这些知识，开发者能够设计出高效、节省资源的嵌入式系统。对于初学者，这是一个...
51单片机实现 定时器计数 数码管显示0到99.rar
04-12
51单片机是微电子技术中广泛应用的一种通用型单片微型计算机，它以其结构...通过学习这个项目，不仅可以掌握51单片机定时器计数的基本操作，还能了解数码管动态显示的原理和方法，对于提升嵌入式系统开发技能大有裨益。
吴鉴鹰单片机项目实战精讲汇总
09-12
这个是吴鉴鹰的单片机精讲，里面有很多的单片机项目
061定时器-数码管中断扫描.rar
02-19
总结来说，"061定时器-数码管中断扫描.rar"资源提供了51单片机使用定时器进行数码管中断扫描的实例，有助于理解和掌握中断系统、定时器的工作原理以及数码管显示技术。通过深入学习和实践，开发者可以将这些技能应用...
3. LED流水灯_流水灯数码管_LED_51单片机_
10-02
本项目主要基于51单片机，通过编写程序来实现LED灯的循环闪烁效果，同时结合数码管显示，提供了一个直观的视觉效果。以下是关于这个主题的详细知识讲解： 1. **51单片机**：51单片机是基于Intel 8051架构的一种微...
51单片机定时器计时并数码管显示计时实验，精度不精确原因记录
Linux_student625的博客
11-16 1714
开篇说明：开发板平台是普中的A7开发板，实验代码及相关注意事项以及精度不精确原因在下面代码注释中有说明。 /******************************************************************************* *实验现象：通过串转并及138译码器控制动态数码管秒表计时 *接 线：P0.0 -> RC, P0.1 -> ...
单片机led数码管显示c语言,各位大神，如何用C语言实现在数码管上实现1234同时亮...
weixin_42327291的博客
05-25 441
该楼层疑似违规已被系统折叠隐藏此楼查看此楼/*将移位寄存器内的数据锁存到输出寄存器并显示 *//*...
蓝桥杯单片机数码管和LED冲突，数码管动态刷新鬼影
NULL指向我的博客
05-12 1812
蓝桥杯单片机数码管和LED冲突，数码管动态刷新鬼影
51单片机按键控制LED灯，数码管
qq_48773375的博客
01-17 2364
51单片机按键控制LED灯，数码管
51单片机的定时器中断（数码管读秒+LED闪烁）
skylisan的博客
04-20 7299
51单片机两种不同的定时器中断程序实例 关于51单片机的定时器系统： 1：51单片机有两组定时器/计数器，因为既可以定时，又可以计数，故称之为定时器/计数器。 2：定时器/计数器和单片机的CPU是相互独立的。定时器/计数器工作的过程是自动完成的，不需要CPU的参与。 3：51单片机中的定时器/计数器是根据机器内部的时钟或者是外部的脉冲信号对寄存器中的数据加1。 4：有了定时器/计数器之后，可以增加单片机的效率，一些简单的重复加1的工作可以交给定时器/计数器处理。CPU转而处理一些复杂的事情。同时可以实现精
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值