【蓝桥杯嵌入式】9届程序题刷题记录及反思

已于 2024-04-09 21:37:23 修改
阅读量383 收藏 3
点赞数 4
文章标签： 蓝桥杯 职场和发展
于 2024-04-04 19:38:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73538444/article/details/137380364
版权

一、题目内容分析

 

二、LCD单字符高亮显示实现 

本次要求显示两个字符，此函数高亮pos及它后面一个字符

void highlight(uint8_t *str,uint8_t pos)
{
	int i = 0;
	for(i = 0; i <= 20; i++)
	{
		if(i != pos && i!= (pos+1))
			LCD_DisplayChar(Line3,(320 - (16 * i)),str[i]);
	}
	LCD_SetBackColor(Yellow);
	LCD_DisplayChar(Line3,(320 - (16 * pos)),str[pos]);
    LCD_SetBackColor(Yellow);
    LCD_DisplayChar(Line3,(320 - (16 * (pos+1))),str[pos+1]);
	LCD_SetBackColor(Black);	
}

 三、EEPROM

我们主要编写这两个函数

//字节写函数
void at24c02_Byte_Write(unsigned char addr,unsigned char cSendByte);
//随机读
unsigned char at24c02_Byte_read(unsigned char addr);

 找到竞赛平台里的资料

字节写： 

  •  起始信号
  • 器件地址————write为低电平 -> 0xa0
  • 等待应答
  • 发送字节地址
  • 等待应答
  • 发送数据
  • 等待应答
  • 结束信号
//字节写函数
void at24c02_Byte_Write(unsigned char addr,unsigned char cSendByte)
{
    I2CStart();
    I2CSendByte(0xa0);
    I2CWaitAck();
    I2CSendByte(addr);
    I2CWaitAck();
    I2CSendByte(cSendByte);
    I2CWaitAck();
    I2CStop();
}

随机读时序 

  • 开始信号
  • 器件地址写——0xa0
  • 等待应答
  • 发送字节地址
  • 等待应答
  • 器件地址读——0xa1
  • 等待应答
  • 接收字节
  • 发送无应答
  • 结束信号
//随机读
unsigned char at24c02_Byte_read(unsigned char addr)
{
    unsigned char dat;
    I2CStart();
    I2CSendByte(0xa0);
    I2CWaitAck();
    I2CSendByte(addr);
    I2CWaitAck();
    I2CStart();
    I2CSendByte(0xa1);
    I2CWaitAck();
    dat = I2CReceiveByte();
    I2CSendNotAck();
    I2CStop();
    return dat;
}

四、usr.c

#include "usr.h"
/* values ------------------------------------------------------------------*/
char time_state = Runing;
struct keys key[4] = {0,0,0,0};
uint8_t storage_location = 1;
uint8_t hour = 1,min = 2,sec = 10;
char timer_run_flag = 0;
int hightlight_sel = -1;
unsigned char read_data = 0;
void read_initial_data(void){
    hour = at24c02_Byte_read(1);
    min  = at24c02_Byte_read(2);
    sec  = at24c02_Byte_read(3);
}
//led
void led_set(uint8_t display)
{
    HAL_GPIO_WritePin(GPIOC,GPIO_PIN_All,GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOC,display<<8,GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
}

//lcd
void display_init(void)
{
    LCD_Init();
    LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
    led_set(0x00);
}
void highlight(uint8_t *str,uint8_t pos)
{
	int i = 0;
	for(i = 0; i <= 20; i++)
	{
		if(i != pos && i!= (pos+1))
			LCD_DisplayChar(Line3,(320 - (16 * i)),str[i]);
	}
	LCD_SetBackColor(Yellow);
	LCD_DisplayChar(Line3,(320 - (16 * pos)),str[pos]);
    LCD_SetBackColor(Yellow);
    LCD_DisplayChar(Line3,(320 - (16 * (pos+1))),str[pos+1]);
	LCD_SetBackColor(Black);	
}

//pwm开始输出
void pwm_out_start(void)
{
    HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_1);
}
//pwm停止输出
void pwm_out_off(void)
{
    HAL_TIM_PWM_Stop(&htim3,TIM_CHANNEL_1);
}

void menu_display(void)
{
    if(time_state!=Runing){
        led_set(0x00);
        pwm_out_off();
    }
    if(timer_run_flag == 1){
        time_state = Runing;
        pwm_out_start();
        
    }else if(timer_run_flag == 0){
        time_state = Pause;

    }else if(timer_run_flag == 2){
        time_state = Standby;
    }else{
        time_state = Setting;
    }
    char text[30];
    sprintf(text,"  No %d              ",storage_location);
    LCD_DisplayStringLine(Line1,(u8*)text);
    
    if(min < 10 && hour <10 && sec<10){                                // 0 0 0
        sprintf(text,"       0%d:0%d:0%d           ",hour,min,sec);
    }else if(hour <10 && min < 10 && sec >= 10){                       // 0 0 1
        sprintf(text,"       0%d:0%d:%2d           ",hour,min,sec);
    }else if(hour <10 && min >= 10 && sec < 10){                       // 0 1 0
        sprintf(text,"       0%d:%2d:0%d           ",hour,min,sec);
    }else if(hour <10 && min >= 10 && sec >= 10){                      // 0 1 1
        sprintf(text,"       0%d:%2d:%2d           ",hour,min,sec);
    }else if(hour >= 10 && min < 10 && sec < 10){                      // 1 0 0
        sprintf(text,"       %2d:0%d:0%d           ",hour,min,sec);
    }else if(hour >= 10 && min < 10 && sec >= 10){                     // 1 0 1
        sprintf(text,"       %2d:0%d:%2d           ",hour,min,sec);
    }else if(hour >= 10 && min >= 10 && sec < 10){                     // 1 1 0
        sprintf(text,"       %2d:%2d:0%d           ",hour,min,sec);
    }else if(hour >= 10 && min >= 10 && sec >= 10){                    // 1 1 1
        sprintf(text,"       %2d:%2d:%2d           ",hour,min,sec);
    }
 
    if(time_state == Setting){
        if(hightlight_sel == hightlight_sel_1){
            highlight((u8*)text,Hightlight_location1);
        }else if(hightlight_sel == hightlight_sel_2){
            highlight((u8*)text,Hightlight_location2);
        }else if(hightlight_sel == hightlight_sel_3){
            highlight((u8*)text,Hightlight_location3);
        }
    }else{
        LCD_DisplayStringLine(Line3,(u8*)text);  
    }
    

    if(time_state == Runing){
        sprintf(text,"       Running          ");
    }else if(time_state == Standby){
        sprintf(text,"       Standby          ");
    }else if(time_state == Setting){
        sprintf(text,"       Setting          ");
    }else if(time_state == Pause){
        sprintf(text,"       Pause          ");
    }
    LCD_DisplayStringLine(Line6,(u8*)text);

}

void timer_cnt(void){
    if(sec == 0){
        sec = 60;
        min --;
        if(min == 0){
            min = 59;
            hour --;
            if(hour == 0){
                hour = 0;
            }
        }
    }
}

void key_control(void){
    //短按
    if(key[0].key_short_flag == 1){        
        //read_data = at24c02_Byte_read(1);
        key[0].key_short_flag = 0;
        storage_location ++;
        if(storage_location > No_5){storage_location = No_1;}
    }else if(key[1].key_short_flag == 1){
        key[1].key_short_flag = 0;
        timer_run_flag = 3;
        time_state = Setting;
        if(time_state == Setting){
            hightlight_sel++;
            hightlight_sel %= 3;
           
        }
    }else if(key[2].key_short_flag == 1){
        key[2].key_short_flag = 0;
        //数字增加
        if(time_state == Setting){
            if(hightlight_sel == hightlight_sel_1){
                hour ++;
                hour %= 60;
            }else if(hightlight_sel == hightlight_sel_2){
                min ++;
                min %= 60;
            }else {
                sec ++;
                sec %= 60;
            }
        }
    }else if(key[3].key_short_flag == 1){
        key[3].key_short_flag = 0;
//        at24c02_Byte_Write(1,2);
//        HAL_Delay(5);
//        at24c02_Byte_Write(2,39);
//        HAL_Delay(5);
//        at24c02_Byte_Write(3,11);
        if(time_state == Setting){
            HAL_TIM_Base_Start_IT(&htim7);
            timer_run_flag = 1;
        }else if(time_state == Standby){            //取消定时器运行
                HAL_TIM_Base_Stop_IT(&htim7);
                timer_run_flag = 0;
        }else{
            //定时器启动
            if(timer_run_flag == 0){
                HAL_TIM_Base_Start_IT(&htim7);
                timer_run_flag = 1;
            }else if(timer_run_flag == 1){
            //定时器暂停   
                HAL_TIM_Base_Stop_IT(&htim7);
                timer_run_flag = 0;
            }
        }
    }
    //长按
    if(key[0].key_long_flag == 1){
        key[0].key_long_flag = 0;
        
    }else if(key[1].key_long_flag == 1){
        key[1].key_long_flag = 0;
        if(time_state == Setting){
            at24c02_Byte_Write(storage_location*3-2,hour);
            HAL_Delay(5);
            at24c02_Byte_Write(storage_location*3-1,min);
            HAL_Delay(5);
            at24c02_Byte_Write(storage_location*3  ,sec);
            HAL_Delay(5);
        }
    }else if(key[2].key_long_flag == 1){
       // key[2].key_long_flag = 0;
        if(time_state == Setting){
            if(hightlight_sel == hightlight_sel_1){
                hour ++;
                hour %= 60;
            }else if(hightlight_sel == hightlight_sel_2){
                min ++;
                min %= 60;
            }else {
                sec ++;
                sec %= 60;
            }
            if(key[2].key_sta == 1){
                key[2].key_long_flag = 0;
            }
        }
    }else if(key[3].key_long_flag == 1){
        key[3].key_long_flag = 0;
        //长按取消定时器运行，回到Standby状态
       // if(timer_run_flag == 1){
            timer_run_flag = 2; 
       // }
    }

}


void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(htim -> Instance == TIM6){
        key[0].key_sta = HAL_GPIO_ReadPin(B1_GPIO_Port,B1_Pin);
        key[1].key_sta = HAL_GPIO_ReadPin(B2_GPIO_Port,B2_Pin);
        key[2].key_sta = HAL_GPIO_ReadPin(B3_GPIO_Port,B3_Pin);
        key[3].key_sta = HAL_GPIO_ReadPin(B4_GPIO_Port,B4_Pin);
        for(uint8_t i = 0;i < 4;i++){
            switch(key[i].key_judge){
                case 0:{
                    if(key[i].key_sta ==  0){
                        key[i].key_judge = 1;
                    }else{
                        key[i].key_judge = 0;
                    }
                }break;
                case 1:{
                    if(key[i].key_sta ==  0){
                        key[i].key_judge = 2;
                    }else{
                        key[i].key_judge = 0;
                    }
                }break;
                case 2:{
                    if(key[i].key_sta ==  1){
                        if(key[i].key_time <= Key_shorttime){
                            key[i].key_short_flag = 1;
                            key[i].key_time = 0;
                            key[i].key_judge = 0;
                        }
                    }else{
                        if(key[i].key_time >= Key_longtime){
                            key[i].key_time = 0;
                            key[i].key_long_flag = 1;
                            key[i].key_judge = 0;
                        }
                        key[i].key_time ++;
                    }
                }break;
            } 
        }
    }
    if(htim -> Instance == TIM7){               //倒计时计时器
        if(timer_run_flag == 1){
            timer_cnt();
            sec --;
        }
    }
    if(htim -> Instance == TIM17){              //led闪烁定时器
        static uint8_t cnt = 0;
        if(timer_run_flag == 1){
            if(cnt<5){
                led_set(0x01);
            }else{
                led_set(0x00);
            }
            cnt++;
            cnt %= 10;        
        }
        else{
             cnt = 0;
        }                                                          

    }
}

五、usr.h

#ifndef __USR_H
#define __USR_H

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "lcd.h"
#include "tim.h"
#include "stdio.h"
#include "i2c_hal.h"
/* defines -------------------------------------------------------------------*/
#define Runing  0 
#define Setting 1
#define Standby 2
#define Pause   3

#define No_1    1     //1-3
#define No_2    2     //4-6
#define No_3    3     //7-9
#define No_4    4     //10-12
#define No_5    5     //13-15

#define Key_longtime  80
#define Key_shorttime 30

#define Hightlight_location1 7
#define Hightlight_location2 10
#define Hightlight_location3 13

#define hightlight_sel_1     0
#define hightlight_sel_2     1
#define hightlight_sel_3     2
/* structs -------------------------------------------------------------------*/
struct keys{
    uint8_t key_sta;
    uint8_t key_judge;
    uint8_t key_short_flag;
    uint8_t key_long_flag;
    uint16_t key_time;
};


void display_init(void);
void menu_display(void);
void key_control(void);
void timer_cnt(void);
void read_initial_data(void);
#endif

六、总结

 I2C的两个引脚不需要额外配置（在cubemx配置）

记得调用"i2c_hal.c"里提供的I2CInit()

cubemx在配置定时器的时候记得开启中断，在while前启动

不爱吃水萝卜
关注
【蓝桥杯嵌入式】第十二届蓝桥杯嵌入式国赛程序设计题
03-01
【蓝桥杯嵌入式】第十二届蓝桥杯嵌入式国赛程序设计题
第十五届蓝桥杯嵌入式省赛真题解析
04-13
在第十五届蓝桥杯嵌入式省赛中，参赛者们可能面临的是对这类系统的理论理解与实践操作的挑战。嵌入式系统广泛应用于各个行业，如消费电子、医疗设备、工业自动化、汽车电子等，其核心在于高效、低功耗、实时性强和...
【蓝桥杯嵌入式】14届程序题刷题记录及反思
weixin_73538444的博客
03-31 919
写了一点学习记录
【蓝桥杯嵌入式】13届程序题刷题记录及反思
weixin_73538444的博客
04-02 907
本次只写一个usr.c usr.h，发现确实方便了许多！！相较于14届难度较小比照LCD的cubemx配置引脚的时候，记得配置PD2（led锁存器引脚）复制其他.h时后记得更改预编译#ifndef __USR_H__ //记得更改#endif#endif#endif如果没有改为__USR_H__,跳转函数跳转不进去usr.c文件，会显示C99_warning。
【蓝桥杯嵌入式】10届程序题刷题记录及反思
weixin_73538444的博客
04-04 240
设置了高亮选择变量->hightlight_sel。
【蓝桥杯嵌入式】12届程序题刷题记录及反思
weixin_73538444的博客
04-07 253
字符分割函数 sscanf 存放在Stdio.h头文件中。判断字符接收格式 如果上面条件不满足就输出error。这个题目的最头痛的就是串口了，在此写下我的思路。定义一个结构体数组，存放每个车位的信息。宏定义两个变量 车辆进入和出去。控制两个led灯，两种状态。
【蓝桥杯嵌入式】11届程序题刷题记录及反思
weixin_73538444的博客
04-02 201
按键输入：短按模拟电压输出：ADCLCD显示PWM输出：PA6,PA7虽然只有PWM输出，但是在比赛中也最好也写输入捕获，来查看pwm输出是否频率和占空比是否正确。
算法零基础到省一的“混”奖经历【第十三届蓝桥杯 Python B组】
一个非常Cool的人
05-01 8589
2022年第十三届蓝桥杯省赛算是结束了，趁五一期间不是很忙写一下自己的参赛心得，是对过去的参赛经历做的总结，也是对未来国赛的展望。希望对博主自身有帮助，也希望对大家有所帮助。
自我反思与暑假及大三上学期规划
2301_76606232的博客
07-02 512
在这个暑假中，我会继续用在CSDN上发布文章的方式来对我学习的知识进行巩固，其中涉及到C++，数据结构与算法，Linux操作系统。在学校开设的课程上，进行QT与51单片机的学习与入门，并在寒假之前彻底完成对QT和GIT的学习，尝试做一个QT方向的项目。但是开学以后，我并没有把重心放在期望自己应该做的事情上，更多的时间花费在了处理学院的相关事务。现在看来，大二学年在专业课的学习上更多的是“碌碌无为”，对于数据结构与算法和C++的学习也是有许多不足，以至于目前为止我仍然觉得自己没有什么能拿得出手的“长处”。
【蓝桥杯单片机】100天如何备赛蓝桥杯单片机
撞上电子
10-23 780
备赛蓝桥杯单片机比赛，需要从以下几个方面进行准备：基础知识掌握首先，需要掌握单片机的基础知识，包括单片机的内部结构、引脚、寄存器、中断、定时器、串口通信等基础概念和原理。了解单片机的开发环境和开发流程，熟悉单片机程序的编写和调试方法。这些基础知识可以通过查阅相关教材、网上资料或者参加相关的课程来学习。硬件设计在单片机比赛中，硬件设计也是非常重要的一部分。需要了解常用的硬件接口和外设，如按键、LED...
大家投下我们腾讯，发的sp鸽麻了，hc又加一千，根本招不到人
华鑫的专栏
05-29 810
很多人觉得华为OD毁简历，你做过od吗，你出去找工作有多少人质疑你，是质疑你做过od还是质疑你能力，后端开发目前的两个offer腾讯base深圳，部门是pcg应用宝，技术栈是go，忘记问具体业务了，进。4/27号结束的hr面，已提交审批base北京，国际电商后端日常，许愿这周内审批通过，让我鸽其他of。二面后三天接到了hr的电话但不是oc，确认一下信息，希望我去北京实习，我说我投递的是上海的，希望在上。一会要华为一面了好像这是最后一批面试了，面完就开始开奖，不知道能不能赶上末班车，希望面试官可以放放水。
第十五届蓝桥杯嵌入式省赛真题题目和答案
04-13
### 第十五届蓝桥杯嵌入式省赛真题题目解析及知识点梳理 #### 嵌入式系统基础知识概述 嵌入式系统是计算机科学的一个分支，它涉及到将微处理器、外围设备和软件集成到一个单一的产品中，以执行特定的任务。这类...
蓝桥杯嵌入式第十届国赛程序（程序及试题）
04-04
在"蓝桥杯嵌入式第十届国赛程序（程序及试题）"这个压缩包中，我们可以深入学习到嵌入式系统设计的关键知识点。 1. **嵌入式硬件基础**：嵌入式系统的硬件包括微处理器、存储器、输入/输出接口、传感器等。第十届...
【蓝桥杯嵌入式】第十一届蓝桥杯嵌入式国赛程序设计题
03-04
【蓝桥杯嵌入式】第十一届蓝桥杯嵌入式国赛程序设计题是针对嵌入式系统开发的一项专业竞赛，旨在检验参赛者的编程技能、硬件理解以及实际问题解决能力。作为一项全国性的赛事，它对于学习和提升嵌入式领域的知识具有...
蓝桥杯模块二：数码管的静态、动态实现
m0_73597306的博客
09-27 334
模块二训练1.静态显示。
蓝桥杯—STM32G431RBT6(TIM定时器输入捕获频率和占空比)
最新发布
JK03820的博客
09-28 565
输入捕获能够对输入信号的上升沿和下降沿进行捕获，并且记录下捕获时定时器的数值以及触发中断。根据功能分为两类：普通输入捕获（只能测频率）PWM输入模式（可以测频率和占空比)(双通道)如图有两个信号发生器，R40和R39可调整信号发生器的频率，PA15和PB4可设置为定时器输入捕获模式，用于采集他所发出的信号 开启定时器 中断回调函数 LCD显示 三、效果展示 通过网盘分享的文件：18-TEST8-TIM输入频率和占空比.zip 链接: https://pan.baidu.
蓝桥杯15届C/C++B组省赛题目
m0_73096516的博客
09-19 2480
队伍 1： {a1,a2,a3}{a1​,a2​,a3​}，队伍 2：{a4,a5}{a4​,a5​}，力量值和分别为 10+9+8=2710+9+8=27 , 12+14=2612+14=26，差距为 ∣27−26∣=1∣27−26∣=1。对于路径经过的棋盘格子，按照经过的格子顺序，上面的数字组成的序列要满足：0,1,2,…,K−1,0,1,2,…例如之前有从 (0,0)(0,0) 移动到 (1,1)(1,1) ，那么再从 (1,0)(1,0) 移动到 (0,1)(0,1) 线路就会交叉。
蓝桥杯24省c
weixin_72770922的博客
09-19 2362
【代码】蓝桥杯24省c。
蓝桥杯嵌入式14届客观题
04-11
但是我可以给你介绍一下蓝桥杯嵌入式竞赛的一般情况。 蓝桥杯嵌入式竞赛是中国著名的计算机竞赛之一，旨在培养和选拔优秀的嵌入式系统开发人才。该竞赛分为两个阶段：初赛和决赛。 初赛阶段，参赛选手需要在线完成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值