第9届蓝桥答案解析

已于 2023-01-23 10:11:51 修改
阅读量109 收藏
点赞数
分类专栏： 蓝桥真题解析 文章标签： 单片机 Powered by 金山文档
于 2023-01-23 10:03:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hvbkbb/article/details/128751649
版权 



# include "reg52.h"
# include "iic.h"
# include "absacc.h"

sbit S7 = P3^0;
sbit S6 = P3^1;
sbit S5 = P3^2;
sbit S4 = P3^3;

unsigned int rb2 = 0;                                //存放读取的Rb2的数据
unsigned char mode = 1;                                //流水灯模式
unsigned int interval[4] = {400,400,400,400};        //4种模式流水灯的流转间隔
unsigned char bright_grade = 4;                         //led灯的亮度等级
unsigned char led_mode[24] = {0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f,0x7f,0xbf,0xdf,0xef,0xf7,0xfb,0xfd,0xfe,0x7e,0xbd,0xdb,0xe7,0xe7,0xdb,0xbd,0x7e};           //24种led流转模式
unsigned char duanma[18] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};               //段码值
unsigned char led_stat = 0;                             //led模式对应的索引值
unsigned int count = 0;                              //定时器T0的计数变量
unsigned char k7 = 0;                                //k7的标志位
unsigned char k6 = 0;                                 //k6的标志位
unsigned int smg_c = 0;                                 //定时器数码管计数变量
unsigned char smg_f = 0;                             //数码管闪烁标志变量
unsigned char pwm_t = 100;                             //脉宽占空比
unsigned int pwm_c = 0;                                 //脉宽计数变量
unsigned char pwm_f = 1;                             //灯亮灭标志变量

void ExecuteRb2 ();
void LEDRunning ();

//======================初始化函数=========================
void InitSystem()
{
    XBYTE[0x8000] = 0xff;
    XBYTE[0xa000] = 0x00;
}
//=========================================================

//====================24C02数据读写操作====================
unsigned char Read24C02(unsigned char addr)
{
    unsigned char tmp;

    IIC_Start();
    IIC_SendByte(0xa0);
    IIC_WaitAck();
    IIC_SendByte(addr);
    IIC_WaitAck();
    
    IIC_Start();
    IIC_SendByte(0xa1);
    IIC_WaitAck();
    tmp = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();
    
    return tmp;    
}

void Write24C02 (unsigned char addr,unsigned char dat)
{
    IIC_Start();
    IIC_SendByte(0xa0);
    IIC_WaitAck();
    IIC_SendByte(addr);
    IIC_WaitAck();
    IIC_SendByte(dat);
    IIC_WaitAck();
    IIC_Stop();        
}
//=========================================================

//====================读取Rb2电位器的值====================
void Readrb2 ()
{
    IIC_Start();
    IIC_SendByte(0x90);
    IIC_WaitAck();
    IIC_SendByte(0x03);
    IIC_WaitAck();
    
    IIC_Start();
    IIC_SendByte(0x91);
    IIC_WaitAck();
    rb2 = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();    
}
//=========================================================

//=====================数码管显示函数======================
void ShowSMG_bit (unsigned char pos,unsigned char dat)
{
    XBYTE[0xc000] = 0x01 << pos - 1;
    XBYTE[0xe000] = dat;
}

void Delay_SMG (unsigned int t)
{
    while (t--);    
}

void AllSMG(unsigned char dat)
{
    XBYTE[0xe000] = 0xff;
    XBYTE[0xc000] = 0xff;
    XBYTE[0xe000] = dat;    
}

void ShowSMG_M ()
{
    ShowSMG_bit(1,duanma[16]);
    Delay_SMG(500);
    if (((k6 == 1) & (smg_f == 1)) | (k6 == 0) | (k6 == 2))
    {
        ShowSMG_bit(2,duanma[mode]);
        Delay_SMG(500);        
    }
    ShowSMG_bit(3,duanma[16]);
    Delay_SMG(500);
    ShowSMG_bit(4,0xff);
    Delay_SMG(500);
    if (((k6 == 2) & (smg_f == 1)) | (k6 == 0) | (k6 == 1))
    {
        if (interval[mode - 1] > 999)
        {
            ShowSMG_bit(5,duanma[interval[mode - 1] / 1000]);
            Delay_SMG(500);    
        }
        ShowSMG_bit(6,duanma[(interval[mode - 1] / 100) % 10]);
        Delay_SMG(500);
        ShowSMG_bit(7,duanma[(interval[mode - 1] / 10) % 10]);
        Delay_SMG(500);
        ShowSMG_bit(8,duanma[interval[mode - 1] % 10]);
        Delay_SMG(500);        
    }
    AllSMG(0xff);
}

void ShowSMG_L ()
{
    ShowSMG_bit(1,0xff);
    Delay_SMG(500);
    ShowSMG_bit(2,0xff);
    Delay_SMG(500);    
    ShowSMG_bit(3,0xff);
    Delay_SMG(500);
    ShowSMG_bit(4,0xff);
    Delay_SMG(500);
    ShowSMG_bit(5,0xff);
    Delay_SMG(500);    
    ShowSMG_bit(6,duanma[16]);
    Delay_SMG(500);
    ShowSMG_bit(7,duanma[bright_grade]);
    Delay_SMG(500);
    ShowSMG_bit(8,duanma[16]);
    Delay_SMG(500);
    AllSMG(0xff);
}
//=========================================================

//=====================定时器T0 100us======================
void InitTime0 ()
{
    TMOD = 0x01;

    TH0 = (65535 - 100) / 256;
    TL0 = (65535 - 100) % 256;

    ET0 = 1;
    EA = 1;
    TR0 = 1;
}

void ServiceTime0 () interrupt 1
{
    TH0 = (65535 - 100) / 256;
    TL0 = (65535 - 100) % 256;

    if (k7 == 1)
    {
        count++;    
    }
    if (count >= (interval[mode - 1] * 10))
    {
        led_stat++;
        count = 0;
    }

    smg_c++;
    if (smg_c >= 5000)
    {
        smg_c = 0;
        if (smg_f == 0)
        {
            smg_f = 1;
        }
        else if (smg_f == 1)
        {
            smg_f = 0;
        }
    }

    pwm_c++;
    if (pwm_c >= pwm_t)
    {
        pwm_f = 0;
        if (pwm_c >= 100)
        {
            pwm_c = 0;
            pwm_f = 1;    
        }
    }
}
//=========================================================

//=====================浏览按键============================
void Delay_Key (unsigned char t)
{
    while (t--);
}

void ScanKey ()
{
    if (S7 == 0)
    {
        Delay_Key(100);
        if (S7 == 0)
        {
            while(S7 == 0)
            {
                ShowSMG_M ();
            }
            if (k7 == 0)
            {
                k7 = 1;
            }
            else if (k7 == 1)
            {
                k7 = 0;    
            }
        }    
    }
    else if (S6 == 0)
    {
        Delay_Key(100);
        if (S6 == 0)
        {
            while(S6 == 0)
            {
                ShowSMG_M ();    
            }
            if (k6 == 0)
            {
                k6 = 1;
            }
            else if (k6 == 1)
            {
                k6 = 2;
            }
            else if (k6 == 2)
            {
                k6 = 0;
            }
        }    
    }
    else if (S5 == 0)
    {
        Delay_Key(100);
        if (S5 == 0)
        {
            while(S5 == 0)
            {
                ShowSMG_M ();
            }
            if (k6 == 1)
            {
                mode++;
                if (mode >= 4)
                {
                    mode = 4;
                }
            }
            else if (k6 == 2)
            {
                interval[mode - 1] = interval[mode - 1] + 100;
                if (interval[mode - 1] >= 1200)
                {
                    interval[mode - 1] = 1200;
                }
                if (mode == 1)
                {
                    Write24C02(0x00,interval[mode - 1] / 10);    
                }
                else if (mode == 2)
                {
                    Write24C02(0x01,interval[mode - 1] / 10);    
                }
                else if (mode == 3)
                {
                    Write24C02(0x02,interval[mode - 1] / 10);    
                }
                else if (mode == 4)
                {
                    Write24C02(0x03,interval[mode - 1] / 10);    
                }
            }
        }    
    }
    else if (S4 == 0)
    {
        Delay_Key(100);
        if (S4 == 0)
        {
            if (k6 == 0)
            {
                while(S4 == 0)
                {
                    ExecuteRb2 ();
                    LEDRunning ();
                    ShowSMG_L ();    
                }    
            }
            else if (k6 == 1)
            {
                while(S4 == 0)
                {
                    ShowSMG_M ();    
                }
                mode = mode -1;
                if (mode <=1)
                {
                    mode = 1;
                }
            }
            else if (k6 == 2)
            {
                while(S4 == 0)
                {
                    ShowSMG_M ();    
                }
                interval[mode - 1] = interval[mode - 1] - 100;
                if (interval[mode - 1] <= 400)
                {
                    interval[mode - 1] = 400;
                }
                if (mode == 1)
                {
                    Write24C02(0x00,interval[mode - 1] / 10);    
                }
                else if (mode == 2)
                {
                    Write24C02(0x01,interval[mode - 1] / 10);    
                }
                else if (mode == 3)
                {
                    Write24C02(0x02,interval[mode - 1] / 10);    
                }
                else if (mode == 4)
                {
                    Write24C02(0x03,interval[mode - 1] / 10);    
                }
            }
        }    
    }
}
//=========================================================

//=======================LED工作===========================
void LEDRunning ()
{
    if (mode == 1)
    {
        if (led_stat > 7)
        {
            led_stat = 0;
        }
        if (pwm_f == 1)
        {
            XBYTE[0x8000] = led_mode[led_stat];    
        }
        else if (pwm_f == 0)
        {
            XBYTE[0x8000] = 0xff;    
        }
    }
    else if (mode == 2)
    {
        if (led_stat < 8 | led_stat > 15)
        {
            led_stat = 8;
        }
        if (pwm_f == 1)
        {
            XBYTE[0x8000] = led_mode[led_stat];    
        }
        else if (pwm_f == 0)
        {
            XBYTE[0x8000] = 0xff;    
        }
    }
    else if (mode == 3)
    {
        if (led_stat < 16 | led_stat > 19)
        {
            led_stat = 16;
        }
        if (pwm_f == 1)
        {
            XBYTE[0x8000] = led_mode[led_stat];    
        }
        else if (pwm_f == 0)
        {
            XBYTE[0x8000] = 0xff;    
        }
    }
    else if (mode == 4)
    {
        if (led_stat < 20 | led_stat > 23)
        {
            led_stat = 20;
        }
        if (pwm_f == 1)
        {
            XBYTE[0x8000] = led_mode[led_stat];    
        }
        else if (pwm_f == 0)
        {
            XBYTE[0x8000] = 0xff;    
        }
    }
}
//=========================================================

//=====================处理rb2的值=========================
void ExecuteRb2 ()
{
    Readrb2 ();
    if (rb2 <= 60)
    {
        bright_grade = 1;
        pwm_t = 25;    
    }
    else if ((rb2 > 60) & (rb2 <= 120))
    {
        bright_grade = 2;
        pwm_t = 50;    
    }
    else if ((rb2 > 120) & (rb2 <= 180))
    {
        bright_grade = 3;
        pwm_t = 75;    
    }
    else if (rb2 > 180)
    {
        bright_grade = 4;
        pwm_t = 100;    
    }
}
//=========================================================

//========================主函数===========================
void main (void)
{
    InitSystem();
    interval[0] = Read24C02(0x00) * 10;
    interval[1] = Read24C02(0x01) * 10;
    interval[2] = Read24C02(0x02) * 10;
    interval[3] = Read24C02(0x03) * 10;
    InitTime0 ();
    while (1)
    {
        ExecuteRb2 ();
        ScanKey ();
        if (k7 == 1)
        {
            LEDRunning ();    
        }
        else if (k7 == 0)
        {
            XBYTE[0x8000] = 0xff;
        }
        ShowSMG_M ();    
    }
}
//=========================================================
vv不说话
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2018年第九届蓝桥杯JAVAB组题目
04-02
2018年4月1日第九届蓝桥杯JAVA组B组题目！2018年4月1日第九届蓝桥杯JAVA组B组题目！
蓝桥官网习题答案汇总
04-03
蓝桥杯官网题库答案-C/C++/Java三种代码，包括VIP试题
第九届省赛程序设计题--彩灯控制器【蓝桥杯真题—02】
z3447643805的博客
03-03 2860
【题目要求】 1.基本功能描述 通过单片机控制8个LED指示灯按照特定的顺序（工作模式）亮灭；指示灯的流转间隔可通过按键调整，亮度可由电位器RB2进行控制；各工作模式的流转间隔时间需在E2PROM中保存，并可在硬件重新上电后，自动载入。 2.设计说明 <1> 关闭蜂鸣器、继电器等与本试题程序设计无关的外设资源。 <2> 设备上电后默认数码管、LED指示灯均为熄灭状态。 <3> 流转间隔可调整范围为400ms-1200ms。 <4> 设备固定安照模式1、模式2
[蓝桥杯国赛]客观题
qq_37443333的博客
07-10 3407
这一位博主讲解了很多题目，强烈推荐 https://blog.csdn.net/ReCclay/article/details/79284285 以下是补充的知识点 记忆 ①直流电源的滤波电路宜选用低通滤波器，可以去除高频干扰 ②具有 PWM 功能的单片机可通过滤波器实现 DAC 功能（联想PWM输出DA端口电压） ③对于STC的单片机是必须的冷启动下载程序，其他单片机很多都不需要这样，因为STC...
【蓝桥杯单片机组】两种外设访问方式：IO编程和MM编程
悟已往之不谏 知来者之可追
02-08 4434
不积跬步无以至千里，不积小流无以成江海。 MM编程仅作为拓展视野，比赛还是最好使用IO来！ 1、IO 扩展模式 通过调节板上跳线 J13 进行配置。其中 IO 扩展模式较为容易理解。 存储器映射扩展模式可以直接通过 XBYTE 关键字来操作部分资源，能够大大简化外设资源程序设计。 IO映射方式控制LED #include "reg52.h" #include "intri...
如何理解XBYTE(转载)
云卷云舒
03-04 1833
转载地址：http://hi.baidu.com/2006051140/blog/item/5f124310b4b3e608203f2e54.html8051 特有的内存型态 code    以 MOVC @A+DPTR 读取的程序内存data    可以直接存取的内部数据存储器idata    以 Mov @Rn 存取的内部数据存储器bdata    可以位寻址（Bi
51单片机 XBYTE
热门推荐
shenhuxi_yu的专栏
01-11 1万+
XBYTE是一个地址指针（可当成一个数组名或数组的首地址），它在文件absacc.h中由系统定义，指向外部RAM（包括I/O口）的0000H单元，XBYTE后面的中括号[ ]0x2000H是指数组首地址0000H的偏移地址，即用XBYTE[0x2000]可访问偏移地址为0x2000的I/O端口。      这个主要是在用C51的P0，P2口做外部扩展时使用，其中XBYTE [0x0002]，P2
第10届蓝桥答案解析
hvbkbb的博客
01-23 105
【代码】第10届蓝桥答案解析。
第8届蓝桥答案解析
hvbkbb的博客
01-23 96
【代码】第8届蓝桥答案解析。
十一届蓝桥真题笔记（自己整理的）
01-15
自急整理的笔记，非常基础的整理方式，我自身也是小白，所以笔记非常简单易懂。大家可以帮我看看哪里有不足，大家一起进步，我也希望大佬们纠正我的错误。
十四届蓝桥选拔赛Scratch-20230312 试题素材
03-14
十四届蓝桥选拔赛Scratch-20230312 试题素材
这是2018年省赛第九届蓝桥杯真题Java(C组)
04-01
这是2018年省赛第九届蓝桥杯真题Java(C组)，新鲜出炉。。
舵机堵转的危害与简单解决方式
最新发布
嵌入式行业打工人，不定期更新博客。
06-13 190
在电机堵转情况下，电流会急剧增加，因为电机需要更多的电力来克服阻力。堵转保护电路会检测到这个异常高的电流，并在电流超过预设阈值时切断电源，从而避免电机过热和损坏。在设计和使用包含舵机的系统时，确保有适当的堵转保护措施是非常重要的，特别是对于那些可能在操作过程中遇到意外阻力的应用，比如机器人手臂、模型飞机的控制表面以及自动化设备中的定位系统。例如，DS-S006M 9克金属齿舵机具有堵转保护功能，意味着它内置了电路来监控其电机的电流消耗，并在检测到堵转情况时自动断电，以保护舵机免受损害。
RH850---注意问题积累--1
weixin_39512905的博客
06-13 517
引脚寄存器----引脚高电位还是低电位引脚读寄存器--只读--获取引脚是高还是低电位引脚模式寄存器--引脚模式是输入还是输出引脚模式控制寄存器---普通模式还是复用模式（备用）引脚模式控制寄存器---普通模式还是复用模式（备用）端口功能控制扩展寄存器--根据功能表配置io的输入输出引脚模式设置复位寄存器register引脚模式控制复位寄存器端口功能控制附加扩展表register引脚反转register引脚缓存register引脚缓存和输出模式配置寄存器。
STM32串口空闲中断接收不定长数据
qq_53381910的博客
06-12 261
STM32串口空闲中断接收不定长数据
TIM—通用定时器&高级定时器
weixin_73839327的博客
06-09 1034
通用/高级定时器的功能 在基本定时器功能的基础上新增功能： 通用定时器有4个独立通道，且每个通道都可以用于下面功能。 （1）输入捕获：测量输入信号的周期和占空比等。 （2）输出比较：产生输出特定的波形（根据自己需要设置）。 （3）输出PWM。 （4）单脉冲模式. （5）级联。（一个定时器的溢出事件可以使能下一个定时器的计数器开始计数） （6）可以触发DAC、ADC。 （7）支持编码器和霍尔传感器电路。
网络编程（三）UDP TFTP协议
weixin_44254079的博客
06-13 289
网络编程 UDP TFTP
上位机图像处理和嵌入式模块部署（f407 mcu项目开发、产品开发）
嵌入式-老费，一个分享专业嵌入式知识的blog
06-10 929
【声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 和做项目、产品相比较，做技术还是比较简单的。一般来说，所谓的技术，就是把相关的功能实现即可。但是做项目和产品的话，约束条件很多。比如说准备做一个产品，首先要知道，这是一个什么样的需求，有没有相关的竞品，成本必须控制在多少，有没有特色功能，通过什么渠道卖出去等等。技术实现只是其中的一个环节。但是一个人，如果只是做技术，而不是去做项目、做产品，长期以往，没有足够回馈的话，也会让自己越做越
第十届蓝桥省赛python
03-02
第十届蓝桥杯省赛是中国著名的计算机竞赛之一，主要面向高中生和大学生。蓝桥杯省赛的Python组是其中的一个竞赛项目，旨在考察参赛选手在Python编程语言方面的能力。 在第十届蓝桥杯省赛Python组中，参赛选手需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值