第七届蓝桥杯嵌入式代码

最新推荐文章于 2024-09-22 22:25:18 发布
最新推荐文章于 2024-09-22 22:25:18 发布
阅读量2.9k 收藏 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;		
}


蓝桥杯嵌入式第七届省赛-液位检测告警系统
fancyZT的博客
04-08 720
一、题目 二、解答 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
本压缩包包含第七届嵌入式蓝桥杯试卷及答案，其中答案为本人根据大神改的；不喜勿碰；仅供参考。
蓝桥杯CT117E嵌入式竞赛板省赛第七届代码
12-01
蓝桥杯嵌入式组省赛代码，第七届代码，功能完全实现，文件内附带题目。电压测量监控设备。 蓝桥杯嵌入式组省赛代码，第七届代码，功能完全实现，文件内附带题目。电压测量监控设备。
第七届蓝桥杯嵌入式（省赛）程序题
菜鸟江多多的博客
05-03 1271
第七届蓝桥杯（省赛）解读+程序解读：这里自己多读几遍设计任务以及要求再看下面`A):先搭总体框架`各初始化函数:`LCD初始化``按键初始化``ADC初始化``i2c初始化``USART2初始化``LED初始化`注：仅展示部分初始化函数，完整程序请下载工程查看`B):LCD处理函数``C):按键处理函数``D):ADC处理函数``E):UART处理函数``F):LED处理函数``G):整体程序设计参考` 解读： 模拟液位检测系统中，实验设计任务要求: 依据实验设计任务，所要用到的片内，.
蓝桥杯嵌入式的学习总结
最新发布
2303_78660417的博客
09-22 1940
因为在我们的产品手册中说明了频率为80MHz，也就是80000000，我们用这个数除以分频系数，再除以重装载值就是我们最后的定时器间隔时间。并且内部上下拉全部断开。4. GPIO端口总共有八种模式，输入模式有四种：上拉输入模式，下拉输入模式，浮空输入，模拟输入。关于IIC通信的相关代码，我们也可以直接使用官方所给的资料当中的代码，我们只需要在此基础上再添加两个代码即可，也就是IIC通信的读取和写入。这里包含了按键的点击，长按的判断，并且使用到了定时器作为中断，用来间隔很短的时间来查询按键是否被按下。
蓝桥杯嵌入式第七届决赛源码
05-03
蓝桥杯嵌入式第七届决赛源码蓝桥杯嵌入式第七届决赛源码蓝桥杯嵌入式第七届决赛源码
第十四届蓝桥杯嵌入式国赛
06-03
在“第十四届蓝桥杯嵌入式国赛”中，参赛者们将面临的是对这种技术的深入理解和应用挑战。 嵌入式系统的构成主要包括硬件和软件两部分。硬件方面，它通常由微处理器、存储器（包括ROM和RAM）、输入/输出接口、电源...
第十二届蓝桥杯嵌入式国赛客观题选择题和资源包.zip
11-14
在第十二届蓝桥杯嵌入式国赛中，参赛者需要掌握以下核心知识点： 1. **处理器架构**：了解各种微处理器和微控制器（如ARM、AVR、MSP430等）的结构、指令集和工作原理。 2. **存储器体系**：包括ROM（只读存储器）...
第七届蓝桥杯嵌入式省赛题目+程序
04-05
【第七届蓝桥杯嵌入式省赛题目+程序】是一个针对嵌入式系统设计的比赛，主要涉及STM32G431微控制器及其相关的开发工具CubeMX。STM32G431是意法半导体（STMicroelectronics）推出的一款基于ARM Cortex-M4内核的微控制...
STM32 第八届蓝桥杯嵌入式省赛程序 模拟升降控制器
02-06
在第八届蓝桥杯嵌入式省赛中，参赛者们可能利用STM32进行模拟升降控制器的设计。蓝桥杯是一项全国性的专业技能竞赛，旨在检验学生在电子设计、软件编程等方面的技能。 首先，我们要理解STM32的架构。STM32系列基于...
蓝桥杯第七届试题-嵌入式.7z
10-01
第七届蓝桥杯全国软件和信息技术专业人才大赛个人赛 （电子类）省赛 嵌入式设计与开发科目“模拟液位检测告警系统”设计任务书
蓝桥杯嵌入式-第七届省赛-模拟液位检测告警系统
10-15
蓝桥杯嵌入式第七届省赛主观题-模拟液位检测告警系统参考代码 已完成全部功能，详情请见博客https://blog.csdn.net/lishan132/article/details/109091657
蓝桥杯嵌入式第七届省赛-模拟液位检测告警系统.pdf
04-04
蓝桥杯嵌入式第七届省赛-模拟液位检测告警系统
第七届蓝桥杯-省赛-试题.pdf
08-18
第七届 蓝桥杯省赛试题 单片机 pdf格式。
蓝桥杯嵌入式（长天嵌入式组织的模拟赛）--程序+代码
04-03
本人在长天组织的模拟赛中，总排名第二。这个压缩包里有程序和题目，需要的下课就可以了。代码规范，没有任何问题。如果对这个工程有任何问题，直接私戳我就可以了。
蓝桥杯嵌入式第十届国赛程序（程序及试题）
04-04
本压缩包包含第十届嵌入式蓝桥杯决赛试卷及答案，程序为本人参考资料所写，基本上是原创；不喜勿喷；仅供参考。
蓝桥杯嵌入式第七届省赛真题
qq_51663309的博客
11-26 2958
蓝桥杯嵌入式第七届省赛真题 代码结尾自取 完全免费！！！！！！ 代码结尾自取 完全免费！！！！！！ 代码结尾自取 完全免费！！！！！！ 目录蓝桥杯嵌入式第七届省赛真题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 1798
第七届蓝桥杯嵌入式省赛赛题实战，文末有工程项目链接，用的是CT117E-M4平台，cubemx和keil开发。
蓝桥杯嵌入式2016第七届省赛真题解答
qq_49552487的博客
04-05 3826
1 题目分析 使用到的外设：LED、LCD、按键、串口、ADC、I2C。 2 Cubemx配置 外设具体方法参考我写的其他文章 配置完成如下： 时钟树配置如下: 3 文件移植 其中灯和按键程序自己添加 添加到项目中 先编译，左边会显示出添加的文件 添加头文后再编译一下，确保头文件和.c文件都被正确引用 4代码 所有的外设配置Cubemx都配置好了，无需自己配置（巨省工作量） 下面介绍自己添加的部分 4.1 led和Key部分 头......
第七届蓝桥杯嵌入式决赛温湿度监控设备代码解析
资源摘要信息:"蓝桥杯嵌入式第七届决赛-温湿度监控设备-工程代码" 标题中提到的“蓝桥杯”是中国计算机学会（CCF）主办的计算机类竞赛活动之一，主要面向大学生以及更高层次的技术人才。竞赛涵盖了算法、软件开发、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值