第七届蓝桥杯嵌入式代码

最新推荐文章于 2024-04-08 16:47:51 发布
最新推荐文章于 2024-04-08 16:47:51 发布
阅读量2.7k 收藏 10
点赞数 6
分类专栏： 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Arthur_Holmes/article/details/79672446
版权 
#include "stm32f10x.h"
#include <stdio.h>
#include "lcd.h"
#include "led.h"
#include "i2c.h"

typedef struct
{
	u8 	show1;
	u8  cai;
	u8  usart;
	u8  c;
	u8  s;
	u8  change;
	u8  qushi;
	u8  set;
	u8  wuci;
	u8  wuci2;
}Flag;

Flag  flag = {1,1,0,0,0,0,3,1,10,10};

u32 TimingDelay = 0;
float ADC_Value;
float pre_ADC_Value;
u32 ADC_Height;
u8 ADC_Level;
u16 Timeing1s;
u16	Timeing200ms;
u8 str[20];
u8 low,mid,high;
__IO uint8_t RxCounter1; 
uint8_t RxBuffer1[15];
uint16_t ReadLED = 0xff;	
		  
void Delay_Ms(u32 nTime);
void Lcd_init(void);
void Gpio_init(void);
u8 Key_scan(void);
void key_check(void);
void show(void);
void Adc_init(void);
void Get_ADC(void);
void Usart_init(void);
void NVIC_Configuration(void);
void sendData(void);
void Led_turn(uint16_t LED);
void Led_OFF(uint16_t LED);


//Main Body
int main(void)
{
	SysTick_Config(SystemCoreClock/1000);
	Lcd_init();
	Gpio_init();
	Adc_init();	
	i2c_init();	
	Usart_init();

	if(i2cRead(0x20) != 20)
	{
		i2cWrite(0x00,30);
		i2cWrite(0x01,50);
		i2cWrite(0x02,70);
		i2cWrite(0x20,20);
	}
 
	low = i2cRead(0x00);
	mid = i2cRead(0x01);
	high = i2cRead(0x02);

	while(1)
	{
		key_check();
		Get_ADC();
		show();
		sendData();	
	}

}


void show(void)
{
	if(flag.show1 == 1)
	{
			LCD_DisplayStringLine(Line0,(unsigned char *)"                    ");
			LCD_DisplayStringLine(Line1,(unsigned char *)"   Liquid Level     ");	
			LCD_DisplayStringLine(Line2,(unsigned char *)"                    ");
			ADC_Height = (u32)(ADC_Value * 30.303);
			sprintf((char *)str," Height: %dcm         ",ADC_Height);
			LCD_DisplayStringLine(Line3,str);
			LCD_DisplayStringLine(Line4,(unsigned char *)"                    ");	
			sprintf((char *)str," ADC: %.2fV           ",ADC_Value);				
			LCD_DisplayStringLine(Line5,str);	
			LCD_DisplayStringLine(Line6,(unsigned char *)"                    ");
			
			pre_ADC_Value =  ADC_Level;

			if(ADC_Height > high)
			ADC_Level = 3;
			if(ADC_Height <= high && ADC_Height > mid)
			ADC_Level = 2;
			if(ADC_Height <= mid && ADC_Height > low)
			ADC_Level = 1;
			if(ADC_Height <= low)
			ADC_Level = 0;

			if(ADC_Level != pre_ADC_Value)
			{	
				flag.change = 1;
				flag.wuci = 10;
			}
			
			if(ADC_Level < pre_ADC_Value)
				flag.qushi = 2;
			if(ADC_Level > pre_ADC_Value)
				flag.qushi = 1;

			sprintf((char *)str," Level: %d           ",ADC_Level);				
			LCD_DisplayStringLine(Line7,str);	
			LCD_DisplayStringLine(Line8,(unsigned char *)"                    ");		
			LCD_DisplayStringLine(Line9,(unsigned char *)"                    ");		
	}
	else 
	{	
			LCD_DisplayStringLine(Line0,(unsigned char *)"                    ");
			LCD_DisplayStringLine(Line1,(unsigned char *)"   Parameter Setup  ");	
			LCD_DisplayStringLine(Line2,(unsigned char *)"                    ");
		
			if(flag.set == 1)
				LCD_SetTextColor(Red);
			sprintf((char *)str," Threshold 1: %dcm        ",low);
			LCD_DisplayStringLine(Line3,str);
			if(flag.set == 1)	
				LCD_SetTextColor(White);
		
			LCD_DisplayStringLine(Line4,(unsigned char *)"                    ");
		
			if(flag.set == 2)
				LCD_SetTextColor(Red);	
			sprintf((char *)str," Threshold 2: %dcm        ",mid);
			LCD_DisplayStringLine(Line5,str);				
			if(flag.set == 2)	
				LCD_SetTextColor(White);

				
			LCD_DisplayStringLine(Line6,(unsigned char *)"                    ");

			if(flag.set == 3)
				LCD_SetTextColor(Red);
			sprintf((char *)str," Threshold 3: %dcm        ",high);	
			LCD_DisplayStringLine(Line7,str);	
			if(flag.set == 3)
				LCD_SetTextColor(White);

			LCD_DisplayStringLine(Line8,(unsigned char *)"                    ");		
			LCD_DisplayStringLine(Line9,(unsigned char *)"                    ");			
	}

}

void sendData(void)
{	
	if(flag.c == 1)
	{
		flag.c = 0;
	
		USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);
	
		printf("C:H%d+L%d\r\n", ADC_Height, ADC_Level); 
		
		USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
	}

	if(flag.s == 1)
	{
		flag.s = 0;
	
		USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);
	
		printf("S:TL%d+TM%d+TH%d\r\n", low, mid, high);  
		
		USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
	} 
	
	if(flag.change == 1)
	{	
		flag.change = 0;

		USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);
	
		if(flag.qushi == 1)
			printf("A:H%d+L%d+U\r\n", ADC_Height, ADC_Level );
		else if(flag.qushi == 2) 
			printf("A:H%d+L%d+D\r\n", ADC_Height, ADC_Level );
		
		flag.qushi = 3;  
		
		USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
	}
}


int fputc(int ch, FILE *f)
{
	 USART_SendData(USART2, (uint8_t) ch);
	 while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
 		 return ch;	
}

void key_check(void)
{	
	u8 Kvalue;
	Kvalue = Key_scan();
	if(Kvalue == 1)
	{
		Kvalue  = 0;
		flag.show1 = ~flag.show1;
		flag.set = 1;
	}

	if(Kvalue == 2)
	{	
		if(flag.show1 != 0)
		{
			flag.set++;
			if(flag.set == 4)
			flag.set = 1;
		}	
		Kvalue  = 0;
	}

	if(Kvalue == 3)
	{
		if(flag.show1 != 0)
		{
			if(flag.set == 1)
			{
				low += 5;
				if(low == mid)
				low -= 5;
			}

			if(flag.set == 2)
			{
				mid += 5;
				if(mid == high)
				mid -= 5;
			}

			if(flag.set == 3)
			{
				high += 5;
				if(high == 105)
				low -= 5;
			}
		}
		Kvalue  = 0;

	   	i2cWrite(0x00,low);
		i2cWrite(0x01,mid);
		i2cWrite(0x02,high);
	}

	if(Kvalue == 4)
	{
		if(flag.show1 != 0)
		{
			if(flag.set == 1)
			{
				low -= 5;
				if(low == 0)
				low += 5;
			}

			if(flag.set == 2)
			{
				mid -= 5;
				if(mid == low)
				mid += 5;
			}

			if(flag.set == 3)
			{
				high -= 5;
				if(high == mid)
				high += 5;
			}
		}
		Kvalue  = 0;

		i2cWrite(0x00,low);
		i2cWrite(0x01,mid);
		i2cWrite(0x02,high);
	}

}

u8 Key_scan(void)
{	
	if(RB1 == 0)
	{
		Delay_Ms(5);
		if(RB1 == 0)
		{
		   	 while(!RB1);
		   	 return 1;	
		}	
	}

	if(RB2 == 0)
	{
		Delay_Ms(5);
		if(RB2 == 0)
		{
			  while(!RB2);
			  return 2;	
		}	
		
	}

	if(RB3 == 0)
	{
		Delay_Ms(5);
		if(RB3 == 0)
		{
		     while(!RB3);
			 return 3;	
		}	
		
	}

	if(RB4 == 0)
	{
		Delay_Ms(5);
		if(RB4 == 0)
		{
			while(!RB4);
	   		return 4;	
		}	
			
	}
	return 0;
}

void NVIC_Configuration(void)
{
  NVIC_InitTypeDef NVIC_InitStructure;

  /* Configure the NVIC Preemption Priority Bits */  
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);

  /* Enable the USARTz Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);


  /******************TIM2定时器中断********************/
//  NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
//  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
//  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
//  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
//
//  NVIC_Init(&NVIC_InitStructure);
}

void Usart_init(void)
{	
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;


	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); 

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  /* Configure USARTy Rx as input floating */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 ;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  

  USART_InitStructure.USART_BaudRate = 9600;
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity = USART_Parity_No;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

  
  USART_Init(USART2, &USART_InitStructure);
  

  /* Enable USARTz Receive and Transmit interrupts */
  USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
  //USART_ITConfig(USART2, USART_IT_TXE, ENABLE);   //不知道为什么，如果开了这个，则会导致错误

  USART_Cmd(USART2, ENABLE);
  NVIC_Configuration();
} 

void Get_ADC(void)
{
	if(flag.cai == 1)
	{
		ADC_SoftwareStartConvCmd(ADC1, ENABLE);
		ADC_Value = ADC_GetConversionValue(ADC1) * 3.3 / 0xfff;
		flag.cai = 0;
	}
}
void Adc_init(void)
{	
	ADC_InitTypeDef  ADC_InitStructure;
	GPIO_InitTypeDef GPIO_InitStructure;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
	
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
	GPIO_Init(GPIOB, &GPIO_InitStructure);


	ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
	ADC_InitStructure.ADC_ScanConvMode = DISABLE;
	ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
	ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
	ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
	ADC_InitStructure.ADC_NbrOfChannel = 1;
	ADC_Init(ADC1, &ADC_InitStructure);
	
	ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 1, ADC_SampleTime_13Cycles5);
	ADC_Cmd(ADC1, ENABLE);
	ADC_ResetCalibration(ADC1);
	while(ADC_GetResetCalibrationStatus(ADC1));
	ADC_StartCalibration(ADC1);
	while(ADC_GetCalibrationStatus(ADC1));	
	ADC_SoftwareStartConvCmd(ADC1, ENABLE);  	
}



void Gpio_init(void)
{	
	GPIO_InitTypeDef GPIO_InitStructure;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |   RCC_APB2Periph_GPIOC |RCC_APB2Periph_GPIOD |
                         RCC_APB2Periph_AFIO, ENABLE);
/**********************************LED_INIT**********************************/
	GPIO_InitStructure.GPIO_Pin = LEDALL;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_Init(GPIOD, &GPIO_InitStructure);
	
	Led_OFF(LEDALL);						    

/**********************************KEY_INIT**********************************/
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_8;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

}

void Lcd_init(void)
{	
	STM3210B_LCD_Init();
	LCD_Clear(Blue);
	LCD_SetBackColor(Blue);
	LCD_SetTextColor(White);
	
	LCD_DisplayStringLine(Line0,(unsigned char *)"  		          ");	
	LCD_DisplayStringLine(Line1,(unsigned char *)"                    ");	
	LCD_DisplayStringLine(Line2,(unsigned char *)"                    ");
	LCD_DisplayStringLine(Line3,(unsigned char *)"                    ");
	LCD_DisplayStringLine(Line4,(unsigned char *)"                    ");					
	LCD_DisplayStringLine(Line5,(unsigned char *)"                    ");	
	LCD_DisplayStringLine(Line6,(unsigned char *)"                    ");	
	LCD_DisplayStringLine(Line7,(unsigned char *)"                    ");	
	LCD_DisplayStringLine(Line8,(unsigned char *)"                    ");		
	LCD_DisplayStringLine(Line9,(unsigned char *)"                    ");	
	
}

//void tim_init(void)
//{
//	  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
//   	
//	  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
//
//	  TIM_TimeBaseStructure.TIM_Period = 1999;
//	  TIM_TimeBaseStructure.TIM_Prescaler = 7199;
//	  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
//	  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
//	
//	  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
//
//	  TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
//
//	  TIM_Cmd(TIM2, ENABLE);
//}

void Led_turn(uint16_t LED)
{
		GPIOC->ODR = ReadLED;	
		ReadLED ^= LED;
		GPIOC->ODR = ReadLED;
		GPIO_SetBits(GPIOD, GPIO_Pin_2);		
		GPIO_ResetBits(GPIOD, GPIO_Pin_2);
	    ReadLED = GPIOC->ODR;
}

void Led_OFF(uint16_t LED)
{
	 	GPIOC->ODR = ReadLED;	
		GPIO_SetBits(GPIOC, LED);
 		GPIO_SetBits(GPIOD, GPIO_Pin_2);				 		
		GPIO_ResetBits(GPIOD, GPIO_Pin_2);
   	  	ReadLED = GPIOC->ODR;
}
void Delay_Ms(u32 nTime)
{
	TimingDelay = nTime;
	while(TimingDelay != 0);	
}

void SysTick_Handler(void)
{
		Timeing1s++;
		if(Timeing1s == 999)
		{
			Timeing1s = 0;		
			flag.cai = 1;
			Led_turn( LED1);
		}

		Timeing200ms++;
		if(Timeing200ms == 199)
		{
			Timeing200ms = 0;		
			if(flag.wuci != 0)
			{
				flag.wuci--;
				Led_turn( LED2);

				if(flag.wuci == 0)
					Led_OFF(LED2);
				
			}
		
			if(flag.wuci2 != 0)
			{
				flag.wuci2--;
				Led_turn( LED3);

				if(flag.wuci2 == 0)
					Led_OFF(LED3);
					
			}
		}
		TimingDelay--;
}

void USART2_IRQHandler(void) 
{
   u8 USART2_RECEIVED;

  if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) 
  {	
	  USART2_RECEIVED=USART_ReceiveData(USART2);
	  RxBuffer1[RxCounter1++] = USART2_RECEIVED;
  }
  if(USART2_RECEIVED == '\n')
  {
 	 USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);

	 if(RxBuffer1[0] == 'C')
	 {
	 	flag.c  = 1;
		flag.wuci2 = 10;
	 }
	 if(RxBuffer1[0] == 'S')
	 {
	 	flag.s  = 1; 
		flag.wuci2 = 10;	 
	 }
	 RxCounter1 = 0;								 //关闭中断之后，效果会很好，但是一旦时间长了之后，还是会造成错误，可能是硬件长期的运行导致的错误
	
	 USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
  }
}




#ifndef __Led_H
#define __Led_H


#define LED1 GPIO_Pin_8              
#define LED2 GPIO_Pin_9               
#define LED3 GPIO_Pin_10              
#define LED4 GPIO_Pin_11             
#define LED5 GPIO_Pin_12               
#define LED6 GPIO_Pin_13                
#define LED7 GPIO_Pin_14                
#define LED8 GPIO_Pin_15              
#define LEDALL GPIO_Pin_All

#define RB1 GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0)
#define RB2 GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_8)
#define RB3 GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1)
#define RB4 GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2)
	  	
#endif

void i2cWrite(unsigned char add,unsigned char data)
{
	I2CStart();
	I2CSendByte(0xa0);
	I2CSendAck();
	I2CSendByte(add);
	I2CSendAck();
	I2CSendByte(data);
	I2CSendAck();
	I2CStop();
	Delay_Ms(10);		
}

unsigned char i2cRead(unsigned char add)
{
	unsigned char temp;
	I2CStart();
	I2CSendByte(0xa0);
	I2CSendAck();
	I2CSendByte(add);
	I2CSendAck();

	I2CStart();
	I2CSendByte(0xa1);
	I2CSendAck();
	temp = I2CReceiveByte();
	I2CStop();
	Delay_Ms(10);
	return temp;		
}


Arthur-Ji
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
蓝桥杯CT117E嵌入式竞赛板省赛第七届代码
12-01
蓝桥杯嵌入式组省赛代码，第七届代码，功能完全实现，文件内附带题目。电压测量监控设备。 蓝桥杯嵌入式组省赛代码，第七届代码，功能完全实现，文件内附带题目。电压测量监控设备。
第七届蓝桥杯嵌入式（省赛）程序题
m0_51095029的博客
05-03 1195
第七届蓝桥杯（省赛）解读+程序解读：这里自己多读几遍设计任务以及要求再看下面`A):先搭总体框架`各初始化函数:`LCD初始化``按键初始化``ADC初始化``i2c初始化``USART2初始化``LED初始化`注：仅展示部分初始化函数，完整程序请下载工程查看`B):LCD处理函数``C):按键处理函数``D):ADC处理函数``E):UART处理函数``F):LED处理函数``G):整体程序设计参考` 解读： 模拟液位检测系统中，实验设计任务要求: 依据实验设计任务，所要用到的片内，.
嵌入式|蓝桥杯STM32G431（HAL库开发）——CT117E学习笔记13：RTC实时时钟
weixin_44800059的博客
04-08 1034
RTC是集成在STM32G4内部的一个模块，我们通过对寄存器的一些配置和读取就可以让他工作在实时时钟的计时模式。
蓝桥杯嵌入式第七届决赛源码
05-03
蓝桥杯嵌入式第七届决赛源码蓝桥杯嵌入式第七届决赛源码蓝桥杯嵌入式第七届决赛源码
蓝桥杯嵌入式第七届省赛-液位检测告警系统
fancyZT的博客
04-08 684
一、题目 二、解答 1.初始化代码 tx.h #include "tx.h" void LED_Init(void){ GPIO_InitTypeDef GPIO_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD, ENABLE); GPIO_InitStructure.G...
蓝桥杯嵌入式第七届试卷及答案
02-19
本压缩包包含第七届嵌入式蓝桥杯试卷及答案，其中答案为本人根据大神改的；不喜勿碰；仅供参考。
蓝桥杯嵌入式-第七届省赛-模拟液位检测告警系统
10-15
蓝桥杯嵌入式第七届省赛主观题-模拟液位检测告警系统参考代码 已完成全部功能，详情请见博客https://blog.csdn.net/lishan132/article/details/109091657
蓝桥杯嵌入式国赛第七届实现代码 温湿度控制器
06-05
蓝桥杯嵌入式国赛第七届实现代码 温湿度控制器
蓝桥杯嵌入式第七届省赛参考代码
04-19
本资料为蓝桥杯嵌入式第七届省赛参考代码，目的是方便查阅。对第七届的真题可以前往蓝桥杯官网下载。
蓝桥杯嵌入式第七届.zip
最新发布
04-22
蓝桥杯大赛，全称是蓝桥杯全国软件和信息技术专业人才大赛，是由中华人民共和国工业和信息化部人才交流中心主办，国信蓝桥教育科技（北京）股份有限公司承办的计算机类学科竞赛。这是一个全国高校参加的赛事，累计...
蓝桥杯第七届试题-嵌入式.7z
10-01
第七届蓝桥杯全国软件和信息技术专业人才大赛个人赛 （电子类）省赛 嵌入式设计与开发科目“模拟液位检测告警系统”设计任务书
蓝桥杯嵌入式第七届省赛-模拟液位检测告警系统.pdf
04-04
蓝桥杯嵌入式第七届省赛-模拟液位检测告警系统
第七届蓝桥杯-省赛-试题.pdf
08-18
第七届 蓝桥杯省赛试题 单片机 pdf格式。
蓝桥杯嵌入式（长天嵌入式组织的模拟赛）--程序+代码
04-03
本人在长天组织的模拟赛中，总排名第二。这个压缩包里有程序和题目，需要的下课就可以了。代码规范，没有任何问题。如果对这个工程有任何问题，直接私戳我就可以了。
蓝桥杯嵌入式第十届国赛程序（程序及试题）
04-04
本压缩包包含第十届嵌入式蓝桥杯决赛试卷及答案，程序为本人参考资料所写，基本上是原创；不喜勿喷；仅供参考。
第七届蓝桥杯嵌入式省赛题目+程序
04-05
包含题目和工程文件，自己备赛期间写的程序，用的是新板子，STM32G431+CubeMX，功能全部实现，内容浅显易懂，如有问题可以联系我。
蓝桥杯嵌入式第七届省赛真题
qq_51663309的博客
11-26 2608
蓝桥杯嵌入式第七届省赛真题 代码结尾自取 完全免费！！！！！！ 代码结尾自取 完全免费！！！！！！ 代码结尾自取 完全免费！！！！！！ 目录蓝桥杯嵌入式第七届省赛真题1.题目2.题目分析3.项目结构3.1 函数结构和全局变量3.2 界面3.3 K3，K4按键控制3.4 串口控制3.5 液位控制3.6 Led控制3.7主函数 1.题目 ​ “模拟液位检测告警系统”通过采集模拟电压信号计算液位高度，并根据用户设定的液位阈值执行报警动作，在液位等级发生变化时，通过串行通讯接口将液位信息发送到 PC
备战蓝桥杯（2）——第七届蓝桥杯嵌入式省赛赛题实战
SUPPER__xxh的博客
01-13 1383
第七届蓝桥杯嵌入式省赛赛题实战，文末有工程项目链接，用的是CT117E-M4平台，cubemx和keil开发。
蓝桥杯嵌入式2016第七届省赛真题解答
qq_49552487的博客
04-05 3711
1 题目分析 使用到的外设：LED、LCD、按键、串口、ADC、I2C。 2 Cubemx配置 外设具体方法参考我写的其他文章 配置完成如下： 时钟树配置如下: 3 文件移植 其中灯和按键程序自己添加 添加到项目中 先编译，左边会显示出添加的文件 添加头文后再编译一下，确保头文件和.c文件都被正确引用 4代码 所有的外设配置Cubemx都配置好了，无需自己配置（巨省工作量） 下面介绍自己添加的部分 4.1 led和Key部分 头......
第九届蓝桥杯嵌入式客观题
04-10
第九届蓝桥杯嵌入式客观题是指蓝桥杯嵌入式类别比赛中的客观题部分。蓝桥杯是中国最具影响力的计算机科学与技术类竞赛之一，旨在发现和培养优秀的计算机人才。嵌入式类别是其中的一个竞赛项目，主要考察参赛选手在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值