蓝桥杯单片机：第九届省赛——彩灯控制器

已于 2023-04-04 14:43:51 修改
阅读量960 收藏 13
点赞数 5
文章标签： 蓝桥杯 51单片机
于 2023-04-04 14:38:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beiciiii/article/details/129952476
版权

#include <reg52.h>
#include "iic.h"

/**************变量定义区******************/
sbit S7=P3^0;
sbit S6=P3^1;
sbit S5=P3^2;
sbit S4=P3^3;
bit Led_Flag;
bit Nixie_Star_Flag;//    数码管闪烁变量 0-灭 1-量
bit Nixie_Dis_Mode;    //  数码管显示模式专用界面 0-参数界面 1-亮度等级
unsigned char Nixie_Data[11]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0xbf};
unsigned int Led_Time_Disp[4]={400,400,400,400};     //流转时间间隔
unsigned int Led_Time_Ctrol[4]={400,400,400,400};    //流转时间间隔控制
unsigned char Led_Time_Index;                                            //模式指针
unsigned int Timer_400ms;    //400ms计时间
unsigned char Nixie_Index;//0-熄灭 1-模式编号亮灭 2-流转时间亮灭
unsigned char EEPROM_Data[4];
unsigned char    Led_Mode;        //1 2 3 4==Led_Time_Index+1;
unsigned int Led_Time;
unsigned char Led_Pos;
unsigned char Led_Level;
unsigned char Led_Count;        //PWM占空比
unsigned char PWM_Duty;
/*******************************************/

void HC573_Select(unsigned char channel);
void Led_Show();
void HC573_Select(unsigned char channel);
void Delay(unsigned int t);

void Timer0_Init()
{
    TMOD=0;
    TH0=(65536-10000)/256;
    TL0=(65536-10000)%256;
    TR0=1;
    EA=1;
    ET0=1;
}

void Timer0_Service() interrupt 1
{
    TH0=(65536-10000)/256;
    TL0=(65536-10000)%256;
    Timer_400ms++;
    Led_Count++;
    if(Timer_400ms==40)
    {
        Nixie_Star_Flag=~Nixie_Star_Flag;
        Timer_400ms=0;
    }
    
    if(Led_Flag==1)
    {
        Led_Time++;                //1Led_Time=10ms
    }
    
    if(Led_Count==100)
    {
        Led_Count=0;
    }
}

void Led_Show()
{
    unsigned char i=0;
    HC573_Select(4);
    if(Led_Flag==1)
    {
        if(Led_Time==Led_Time_Ctrol[Led_Mode]/10)
        {
            Led_Time=0;
            switch(Led_Mode)
            {
                case 0:
                    Led_Pos++;
                    if(Led_Pos==8)
                    {
                        Led_Pos=7;
                        Led_Mode=1;
                    }
                    break;
                case 1:
                    Led_Pos--;
                    if(Led_Pos==255)
                    {
                        Led_Pos=0;
                        Led_Mode=2;
                    }
                    break;
                case 2:
                    Led_Pos++;
                    if(Led_Pos>3)
                    {
                        Led_Pos=0;
                        Led_Mode=3;
                    }
                    break;
                case 3:
                    Led_Pos++;
                    if(Led_Pos>3)
                    {
                        Led_Pos=0;
                        Led_Mode=0;
                    }
            }
        }
        if(Led_Mode<2)
        {
            P0=~(0x01<<Led_Pos);
            Delay(PWM_Duty);
            P0=0XFF;
            Delay(100-PWM_Duty);
        }
        if(Led_Mode==2)
        {
            P0=~(0x81<<Led_Pos|0x81>>Led_Pos);
            Delay(PWM_Duty);
            P0=0XFF;
            Delay(100-PWM_Duty);
        }
        if(Led_Mode==3)
        {
            P0=~(0x10<<Led_Pos|0X08>>Led_Pos);
            Delay(PWM_Duty);
            P0=0XFF;
            Delay(100-PWM_Duty);
        }
    }
}

void HC573_Select(unsigned char channel)
{
    switch(channel)
    {
        case 4:
            P2=(P2&0X1f)|0x80;
            break;
        case 5:
            P2=(P2&0X1f)|0xa0;
            break;
        case 6:
            P2=(P2&0X1f)|0xc0;
            break;
        case 7:
            P2=(P2&0X1f)|0xe0;
            break;
    }
}

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

void Nixie_Display(unsigned char pos,val)
{
    HC573_Select(6);
    P0=0x01<<pos;
    HC573_Select(7);
    P0=val;
    Delay(100);
    P0=0xff;
}

void Nixie_CloseAll()
{
    unsigned char i;
    for(i=0;i<8;i++)
    {
        Nixie_Display(i,0xff);
    }
}

void Nixie_Show()
{
    if(Nixie_Dis_Mode==0)                        //处于参数界面
    {
        if(Nixie_Index==0)
        {
            Nixie_CloseAll();
        }
        else if(Nixie_Index==1)
        {
            if(Nixie_Star_Flag==0)            //模式编号亮灭
            {
                Nixie_Display(0,0xff);        
                Nixie_Display(2,0xff);
                Nixie_Display(1,0xff);
            }
            else if(Nixie_Star_Flag==1)
            {
                Nixie_Display(0,0xbf);        
                Nixie_Display(2,0xbf);
                Nixie_Display(1,Nixie_Data[Led_Time_Index+1]);
            }
            if(Nixie_Data[Led_Time_Disp[Led_Time_Index]/1000%10]==0xc0)    
            {
                Nixie_Display(4,0xff);
            }
            else
            {
                Nixie_Display(4,Nixie_Data[Led_Time_Disp[Led_Time_Index]/1000%10]);
            }
            Nixie_Display(5,Nixie_Data[Led_Time_Disp[Led_Time_Index]/100%10]);
            Nixie_Display(6,Nixie_Data[Led_Time_Disp[Led_Time_Index]/10%10]);
            Nixie_Display(7,Nixie_Data[Led_Time_Disp[Led_Time_Index]%10]);
        }
        else if(Nixie_Index==2)
        {
            Nixie_Display(0,0xbf);        
            Nixie_Display(2,0xbf);
            Nixie_Display(1,Nixie_Data[Led_Time_Index+1]);
            if(Nixie_Star_Flag==0)            //流转时间亮灭
            {
                Nixie_Display(4,0xff);        
                Nixie_Display(5,0xff);
                Nixie_Display(6,0xff);
                Nixie_Display(7,0xff);
            }
            else if(Nixie_Star_Flag==1)
            {
                if(Nixie_Data[Led_Time_Disp[Led_Time_Index]/1000%10]==0xc0)    
                {
                    Nixie_Display(4,0xff);
                }
                else
                {
                    Nixie_Display(4,Nixie_Data[Led_Time_Disp[Led_Time_Index]/1000%10]);
                }
                Nixie_Display(5,Nixie_Data[Led_Time_Disp[Led_Time_Index]/100%10]);
                Nixie_Display(6,Nixie_Data[Led_Time_Disp[Led_Time_Index]/10%10]);
                Nixie_Display(7,Nixie_Data[Led_Time_Disp[Led_Time_Index]%10]);
            }
        }
    }
}

void Keys_Scan()
{
    unsigned char i=0;
    if(S7==0)
    {
        Delay(50);
        if(S7==0)
        {
            Led_Flag=~Led_Flag;                //1亮 0灭 LED
        }
        while(S7==0)
        {
            Led_Show();
        }
    }
    if(S6==0)
    {
        Delay(50);
        if(S6==0)
        {
            if(Nixie_Index==0)
            {
                Nixie_Index=1;
            }
            else if(Nixie_Index==1)
            {
                Nixie_Index=2;
            }
            else if(Nixie_Index==2)
            {
                Nixie_Index=0;
            }
            if(Nixie_Index==0)
            {
                for(i=0;i<4;i++)
                {
                    Led_Time_Ctrol[i]=Led_Time_Disp[i];
                    EEPROM_Data[i]=Led_Time_Ctrol[i]/100;
                }
                EEPROM_Write(EEPROM_Data,0,4);
            }
        }
        while(S6==0)
        {
            Nixie_Show();
            Led_Show();
        }
    }
    if(S5==0)
    {
        Delay(50);
        if(S5==0)
        {
            if(Nixie_Dis_Mode==0&&Nixie_Index==1)
            {
                ++Led_Time_Index;
                if(Led_Time_Index==4)
                {
                    Led_Time_Index=0;
                }
            }
            else if(Nixie_Dis_Mode==0&&Nixie_Index==2)
            {
                Led_Time_Disp[Led_Time_Index]=Led_Time_Disp[Led_Time_Index]+100;
                if(Led_Time_Disp[Led_Time_Index]>1200)
                {
                    Led_Time_Disp[Led_Time_Index]=400;
                }
            }
        }
        while(S5==0)
        {
            Nixie_Show();
            Led_Show();
        }
    }
    if(S4==0)
    {
        Delay(50);
        if(S4==0)
        {
            if(Nixie_Dis_Mode==0&&Nixie_Index==1)
            {
                Led_Time_Index--;
                if(Led_Time_Index>99)
                {
                    Led_Time_Index=3;
                }
            }
            else if(Nixie_Dis_Mode==0&&Nixie_Index==2)
            {
                Led_Time_Disp[Led_Time_Index]=Led_Time_Disp[Led_Time_Index]-100;
                if(Led_Time_Disp[Led_Time_Index]<400)
                {
                    Led_Time_Disp[Led_Time_Index]=1200;
                }
            }
            if(Nixie_Index==0)
            {
                while(S4==0)
                {
                    for(i=0;i<6;i++)
                    {
                        Nixie_Display(i,0xff);
                    }
                    Nixie_Display(6,0xbf);
                    Nixie_Display(7,Nixie_Data[Led_Level+1]);
                    Led_Show();
                }
            }
            while(S4==0)
            {
                Nixie_Show();
                Led_Show();
            }
        }
    }
}

void Ad_Init()
{
    Led_Level=AD_Read(0x43)/64;
    if(Led_Level==0)
    {
        PWM_Duty=25;
    }
    else if(Led_Level==1)
    {
        PWM_Duty=50;
    }
    else if(Led_Level==2)
    {
        PWM_Duty=75;
    }
    else if(Led_Level==3)
    {
        PWM_Duty=100;
    }
}

void main()
{
    unsigned char i;
    Timer0_Init();
    EEPROM_Read(EEPROM_Data,0,4);
    for(i=0;i<4;i++) 
    {
        Led_Time_Ctrol[i]=Led_Time_Disp[i]=EEPROM_Data[i]*100;
    }
    while(1)
    {
        Ad_Init();
        Led_Show();
        Nixie_Show();
        Keys_Scan();
    }
}

作者水平有限，代码比较冗杂，有需要的同学辩证地看。

学习到的点：

1.EEPROM读写代码的学习，具体代码如下：

void EEPROM_Write(unsigned char* EEPROM_String,unsigned char addr,unsigned char num)
{
    I2CStart();                    //发送开启信号
    I2CSendByte(0xA0);    //选择EEPROM芯片 确定模式
    I2CWaitAck();               //等待EEPROM反馈
    
    I2CSendByte(addr);    //写入要存储的地址
    I2CWaitAck();             //等待EEPROM反馈
    
    while(num--)
    {
        I2CSendByte(*EEPROM_String++);    //将要写入的信息写入
        I2CWaitAck();                                       //等待EEPROM反馈
        I2C_Delay(200);                                   //等待
    }
    
    I2CStop();
}

void EEPROM_Read(unsigned char* EEPROM_String,unsigned char addr,unsigned char num)
{
    I2CStart();
    I2CSendByte(0XA0);
    I2CWaitAck();
    
    I2CSendByte(addr);
    I2CWaitAck();
    
    I2CStart();
    I2CSendByte(0XA1);
    I2CWaitAck();
    
    while(num--)
    {
        *EEPROM_String++=I2CReceiveByte();
        if(num)
        {
            I2CSendAck(0);
        }
        else
        {
            I2CSendAck(1);
        }
    }
    
    I2CStop();
}

2.PCF8591芯片实现的AD/DA转换，代码如下：

unsigned char AD_Read(unsigned char addr)        //PCF8591 滑变 0X43 光敏 0X41;
{        
    unsigned char temp;
    I2CStart();
    I2CSendByte(0x90);        //告诉PCF8591开始读
    I2CWaitAck();
    
    I2CSendByte(addr);        //告诉PCF8591哪里开始读
    I2CWaitAck();
    
    I2CStart();
    I2CSendByte(0x91);
    I2CWaitAck();
    
    temp=I2CReceiveByte();
    I2CSendAck(1);                //读出来后发送非应答信号 因为只需要读一次
    I2CStop();
    
    return temp;
}

void DA_Write(unsigned char addr)
{
    I2CStart();
    I2CSendByte(0x90);
    I2CWaitAck();
    I2CSendByte(0X41);
    I2CWaitAck();  
    I2CSendByte(addr);
    I2CWaitAck();
    I2CStop();
}

3.按键导致的状态改变应该单独设置变量。

元亨利贞-_-
关注
  • 5
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
蓝桥杯第九届彩灯控制器源码
03-23
蓝桥杯第九届初赛试题源码，有注释，可以参考使用，主要是逻辑关系上的思考，赛题包含数码管选中闪烁，按键长按，按键复用，AD的读取，at24c02的读和写，以及这些模块的逻辑配合。
蓝桥杯单片机省赛第九届彩灯控制
qq_57857897的博客
03-11 1565
蓝桥杯单片机省赛
蓝桥杯第九届省赛真题代码——彩灯控制器-附详细讲解思路
最新发布
qq_43323677的博客
04-10 652
首先，添加头文件，搭建最底层的代码，实现基本的流水灯运转与数码管显示rb2的电阻值然后，进行pwm脉宽调制，实现rb2数值不同，从而灯光亮度不同。并作出数码管的多窗口切换接着，完成4个独立按键的功能配置，每写一个按键，就把一个按键的功能完善好再是，测试数码管的显示效果，这个至关重要，保证每个数码管显示效果较好最后，编写24c02的程序。
第九届蓝桥杯单片机省赛题目解析
qq_53221728的博客
09-01 8238
第九届蓝桥杯单片机省赛题目解析 这次的题目依然还是用到了三大模块（数码管、LED、按键），还用到了EEPROM和模拟输入（ADC），也都是一些常见的外设，只要平常都练习过，也就不难，最重要的还是编程逻辑。 1 数码管显示 数码管有两个界面需要显示一个是设置状态的界面，还有一个是亮度等级界面。设置状态界面由运行模式和流转间隔组成。 2 LED显示 这次的LED是重点，不仅有四种运行模式还有四个亮度等级。四种运行模式就设置数组，然后循环运行。四个...
蓝桥杯单片机第九届省赛编程题（深夜学习——单片机）
weixin_63568691的博客
03-10 1439
蓝桥杯单片机第九届省赛编程题
蓝桥杯单片机第九届省赛题详细讲解(彩灯控制器)
darlingqx的博客
10-31 4640
然后接着往下看题目。**首先还是从题目的程序框图准备起。****将程序框图的PCF8591(模拟输入)，按键，数码管，EEPROM都先调试好。****然后看一下基本功能，让自己对整个流程有一个了解。再将彩灯控制的LED的四种模式准备好。这里我建议是用数组把状态保存起来****然后继续看题，这里亮度调节需要调节pwm占空比来实现，所以先放一下，先把Rb2电压转化为4个等级。****做完这些，接下来就是调节LED模式和亮度度，当然这些肯定是都需要在定时器里进行调节的。** **间隔调节就是按照规定的间隔进行亮灭
第九届“蓝桥杯”单片机省赛——程序设计题
HallelujahYoung的博客
04-01 3431
第九届“蓝桥杯”单片机省赛——程序设计题 个人编写，代码仅供参考 如有不足，多多指教 1.题目 2.代码 main.c程序 #include "reg52.h" #include "iic.h" #include "intrins.h" #define uchar unsigned char #define uint unsigned int uchar code smg[] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x...
蓝桥杯单片机第九届省赛-彩灯控制器官方例程完整源码
03-30
总结来说，蓝桥杯单片机第九届省赛的彩灯控制器项目，不仅考察了参赛者的单片机编程能力，还涉及到硬件接口操作、控制逻辑设计、程序优化等多个方面。通过对官方例程的深入理解和实践，开发者能够提升自己的综合技能...
蓝桥杯单片机第九届省赛'彩灯控制器'程序实现
03-15
"蓝桥杯单片机第九届省赛'彩灯控制器'程序实现"是一个关于嵌入式系统设计的项目，主要集中在单片机编程上。蓝桥杯是一项知名的全国性大学生IT技术竞赛，涵盖软件和电子设计等多个领域。在这个特定的比赛中，参赛者...
2018_第九届_蓝桥杯_省赛——“彩灯控制器”
03-03
2018_第九届_蓝桥杯_省赛——“彩灯控制器”的程序与调试
蓝桥杯单片机第九届初赛试题-彩灯控制器_工程代码
05-19
《蓝桥杯单片机第九届初赛试题——彩灯控制器工程代码解析》 在电子技术领域，单片机是一种集成了微处理器、存储器、输入/输出接口等多功能于一体的集成电路，广泛应用于各种自动化设备和控制系统。蓝桥杯是一项...
蓝桥杯——第九届蓝省赛_彩灯控制器
01-06
一、使用到的模块 使用到的模块 数码管、按键、LED、AD、eeprom 二、代码部分 实验平台：CT107D 实验芯片：stc15f2k60s2 实验现象：完成题目要求 代码如下 ...void Delay5us() //@12.000MHz ... SCL =
蓝桥杯第九届省赛----彩灯控制器（注释详细）
weixin_64313535的博客
06-17 1970
（b）在非“设置状态”下，按下 S4 按键可显示指示灯当前的亮度等级， 4 个亮度等级从暗到亮，依次用数字 1、 2、 3、 4 表示；（3）按键 S5 定义为“加”按键，在设置界面下，按下该键，若当前选择的是运行模式，则运行模式编号加 1，若当前选择的是流转间隔，则流转间隔增加 100ms。（4）按键 S4 定义为“减”按键，在设置界面下，按下该键，若当前选择的是运行模式，则运行模式编号减 1，若当前选择的是流转间隔，则流转间隔减少 100ms。段选：控制每一位数码管亮的二级管的个数，比如上面的。
蓝桥杯单片机第九届省赛客观题（深夜学习——单片机）
weixin_63568691的博客
03-26 908
蓝桥杯单片机第九届省赛客观题
蓝桥杯单片机第9届省赛程序题参考答案
因心，三人水的博客
02-13 1458
蓝桥杯单片机第9届省赛程序题参考答案
第九届蓝桥杯单片机省赛题‘彩灯控制器’程序实现
diksan的博客
03-11 3904
第九届蓝桥杯大赛单片机组省赛题程序题代码以及功能实现
【蓝桥杯】第九届单片机省赛
weixin_51545907的博客
04-07 1123
【蓝桥杯】第九届单片机省赛 蓝桥杯省赛【蓝桥杯】第九届单片机省赛题目代码参考总结 题目 代码参考 #include "reg52.h" #include "iic.h" typedef unsigned char uint8; typedef unsigned int uint32; #define LED_Channel 4 #define BEEP_RELAY_Channel 5 #define COM_Channel 6 #define SMG_Channel 7 uint8 c
【蓝桥杯单片机国赛 第九届】
qq_45720531的博客
04-07 4362
蓝桥杯国赛模块讲解 蓝桥杯国赛第九届 题目 做题思路 首先写上要做的模块，界面，按键细节 一页纸就能让你不用看pdf即可写出整套题 简单示范： 突然就觉得很简单了对不对，笼统看就写几个模块，外加几个界面~ 下面，我就参照我是如何思考以及我的写题策略来讲解第九届的国赛题啦 首先smg测试 void smg() { P2 = (P2&0x1f)|0xc0; P0 = T_COM[smg_i]; P2 = (P2&0x1f); P2 = (P2&0x1f)|0xe0; P0
蓝桥杯单片机第九届省赛
m0_73157818的博客
02-20 677
本程序借鉴了的代码风格。记录下自己学习过程中的代码。依旧是和大白话一样简单繁琐的代码。这一届感觉难度挺大，一开始题目都看不太懂，后续也有不少小bug，不过最后只有pwm处理的不太好，亮度低的时候会闪，其余的问题不大。
蓝桥杯第9届省赛-彩灯控制器-hex文件
01-18
蓝桥杯第9届省赛彩灯控制器的hex文件是指经过编译后生成的可以直接下载到单片机中的机器语言文件。这个文件包含了控制彩灯的程序指令和数据，可以直接在相应的硬件设备中运行。 彩灯控制器的hex文件通过编译软件生成，其中包含了一系列的机器指令，这些指令可以让单片机根据预先设计好的控制策略来控制彩灯的亮灭、颜色变化等操作。在比赛中，选手需要准备好这个hex文件，并将其下载到指定的硬件平台中，从而让设备按照既定的规则来进行彩灯控制。 通过正确的hex文件，选手可以将自己设计好的控制算法运行在硬件平台上，实现对彩灯的精准控制。这对于比赛中的彩灯控制任务来说至关重要，因为只有通过正确的hex文件，才能在竞赛中展现出自己的设计理念和技术实力。 因此，彩灯控制器的hex文件是比赛中不可或缺的一部分，它是选手思想和机器互动的桥梁，是实现彩灯控制任务的关键。在比赛中，选手需要务必保证hex文件的正确性和完整性，以确保自己的设计能够顺利地在硬件平台上得到体现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值