第七届蓝桥杯嵌入式省赛"电压测量监控设备"

最新推荐文章于 2024-04-10 16:03:37 发布
最新推荐文章于 2024-04-10 16:03:37 发布
阅读量545 收藏 1
点赞数 2
分类专栏： 蓝桥杯 文章标签： 蓝桥杯 嵌入式 省赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/I_LOVE_MCU/article/details/101320713
版权

题目如下
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
主要代码如下

//main.c
#include "includeall.h"

vu32 TimingDelay = 0;

void Init(void)
{
	Usart2_Init(9600);	
	SysTick_Config(SystemCoreClock/1000);//初始化滴答定时器时钟
	
	Delay_Ms(200);

	LED_Init();	
	STM3210B_LCD_Init();//初始化LCD显示屏
	Beep_Init();
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);	
	i2c_init();
	Key_Init();
	//EXTI0_Init();
	//EXTI8_Init();
	TIM2_Init(1999, 7199);//200ms
	TIM3_Init(79, 7199);//8ms
	ADC8_Init();
	RTC_Init();
}
//Main Body
int main(void)
{
	Init();
		
	LCD_Clear(White);//清屏
	LCD_SetBackColor(White);//改背景
	LCD_SetTextColor(Black);//改字色
	
	
	while(1)
	{	
		LCD_Show();
		KeyMonitor();
		LED_Shine();
		usartDataJudge();
		
	}
}

//
void Delay_Ms(u32 nTime)
{
	TimingDelay = nTime;
	while(TimingDelay != 0);	
}

//usart.c
#include "includeall.h"
#include "../Driver/USART/usart.h"

void Usart2_Init(u32 baud)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	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);
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//
    GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	USART_InitStructure.USART_BaudRate = baud;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	
	USART_Init(USART2, &USART_InitStructure);
	
	NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_Init(&NVIC_InitStructure);
	
	USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//
	
	USART_Cmd(USART2, ENABLE);
}

void USART2_SendByte(u8 data)
{
	USART_ClearFlag(USART2, USART_FLAG_TC);
	USART_SendData(USART2, data);
	while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == 0);//
}

void USART2_SendString(u8 *str)
{
	u8 i=0, num = 0;
	
	while(str[i]!=0)
		i++;
	num = i;
	for(i=0; i<num; i++)
	{
		USART2_SendByte(str[i]);
	}
		
}

void USART2_IRQHandler(void)
{
	u8 res = 0;	
	
	if( USART_GetITStatus(USART2, USART_IT_RXNE) )
	{
		TIM_SetCounter(TIM3, 0);
		res = USART_ReceiveData(USART2);
		
		if(g_stopreceive == 0)
		{
			g_usartrec[g_usartnum] = res;
			g_usartnum++;
		}
		else
		{
			TIM_Cmd(TIM3, ENABLE);
			g_usartnum = 0;
			g_stopreceive = 0;
			memset((void *)g_usartrec, 0, 50);
			g_usartrec[g_usartnum] = res;
			g_usartnum++;
		}
	}
}


int fputc(int ch, FILE *f){
  /* Place your implementation of fputc here */
  /* e.g. write a character to the USART */
  USART_SendData(USART2, (uint8_t) ch);

  /* Loop until the end of transmission */
  while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET)
  {}

  return ch;
}


//includeall.c
#include "includeall.h"

volatile double g_V = 0;
volatile u8 g_K = 1;

volatile u8 g_LS = 1;
volatile u8 g_LK = 1;

vu8 g_TimeDisplay = 0;
volatile Tim_str g_timtemp = {23, 59, 55};
volatile Tim_str g_settime = {0, 0, 0};

volatile u8 g_page = MAIN;

volatile u8 g_underline = 0;

volatile u8 g_usartrec[50];
volatile u8 g_stopreceive = 1;
volatile u8 g_usartnum = 0;
volatile u8 g_iicsr = 0;

void LCD_DisplayADC(void)
{
	u8 strtem[10];
	u8 i = 0, num = 0;
	
	//USART2_SendString("LCD_DisplayADC1");
	sprintf((char *)strtem, "%5.2lfV", ADC_Measure() );
	//USART2_SendString("LCD_DisplayADC2");
	while(strtem[i]!=0)i++;
	num = i;
	//USART2_SendString("LCD_DisplayADC");
	for(i=0; i<num; i++)
		LCD_DisplayChar(Line5, 319-16*(4+i), strtem[i]);
	//LCD_DisplayStringLine(Line6 ,(unsigned char *)strtem);
}


void My_LCD_DisplayChar(u8 Line, u16 Add, u8 Ascii)
{
	LCD_DisplayChar(Line, 319-16*Add, Ascii);
}


void My_LCD_DisplayStringLine(u8 Line, u16 Add, u8 *ptr)
{
	u32 i = 0;

	while ((*ptr != 0) && (i < 20))	 //	20
	{
		My_LCD_DisplayChar(Line, Add+i, *ptr);
		ptr++;
		i++;
	}
}

double ADC_Measure(void)
{
	g_V = ADC_Get_Ave(8,5)/4096.0*3.3;
	return g_V;
}


void LED_Shine(void)
{
	if (g_LK == 1)
	{
		if(g_V > 0.33*g_K)
		{
			g_LS = 1;
		}
		else
		{
			g_LS = 0;
		}
	}
	else
	{
		LEDOff(LED1);
		g_LS = 0;
	}
}

void LCD_Show(void)
{
	u8 strtemp[20];
	
	if(g_page == MAIN)
	{
		sprintf( (char *)strtemp, "  V1:%4.2lfV", ADC_Measure());
		LCD_DisplayStringLine(Line2, strtemp);
		sprintf( (char *)strtemp, "  k:0.%d", g_K);
		LCD_DisplayStringLine(Line3, strtemp);
		if(g_LK)
			LCD_DisplayStringLine(Line4, (u8 *)"  LED:ON ");
		else
			LCD_DisplayStringLine(Line4, (u8 *)"  LED:OFF ");
		Time_Show();
		sprintf( (char *)strtemp, "  T:%2d-%2d-%2d", g_timtemp.hh, g_timtemp.mm, g_timtemp.ss);
		LCD_DisplayStringLine(Line5, strtemp);
		
	}
	else if(g_page == SETT)
	{
		LCD_DisplayStringLine(Line3, (u8 *)"    Setting ");
		sprintf( (char *)strtemp, "  %2d-%2d-%2d", g_settime.hh, g_settime.mm, g_settime.ss);
		LCD_DisplayStringLine(Line5, strtemp);
		if(g_underline%3 == 2)
			LCD_DisplayStringLine(Line6, (u8 *)"  __        ");
		else if(g_underline%3 == 1)
			LCD_DisplayStringLine(Line6, (u8 *)"     __     ");
		else if(g_underline%3 == 0)
			LCD_DisplayStringLine(Line6, (u8 *)"        __  ");
	}
}


void ReportVoltage(void)
{
	u8 data[25];
	
	sprintf((char*)data, "%.2lf+0.%d+%2d%2d%2d\n", g_V, g_K, g_timtemp.hh, g_timtemp.mm, g_timtemp.ss);
	USART2_SendString(data);
}

void KeyMonitor(void)
{
	if(g_page == MAIN)
	{
		switch(Key_Scan(0) ){
			case K1_PRES:
			{
				//printf("K1_PRES\r\n");
				g_LK = !g_LK;
			}
			break;
			case K2_PRES:
			{
				//printf("K2_PRES\r\n");
				//USART2_SendString("K22_PRES\r\n");
				LCD_Clear(White);
				g_page = SETT;			
			}			
		}	
	}
	else if(g_page == SETT)
	{		
		switch(Key_Scan(0) ){
			case K1_PRES:
			{
				g_LK = !g_LK;
			}
			break;
			case K2_PRES:
			{
				RTC_SetAlarm(Time_Regulate(g_settime.hh, g_settime.mm, g_settime.ss) );
				RTC_WaitForLastTask();
				LCD_Clear(White);
				g_page = MAIN;
			}
			break;
			case K3_PRES:
			{
				g_underline++;
			}
			break;
			case K4_PRES:
			{
				k4settime();				
			}
		}
	}
}


void k4settime(void)
{
	if(g_underline%3 == SUL)
	{
		if(g_settime.ss != 59 )
		{
			g_settime.ss++;
		}
		else
		{
			g_settime.ss=0;
			if(g_settime.mm != 59)
				g_settime.mm++;
			else
			{
				g_settime.mm = 0;
				g_settime.hh++;
			}							
		}
	}
	else if(g_underline%3 == MUL)
	{
		if(g_settime.mm != 59 )
		{
			g_settime.mm++;
		}
		else
		{
			g_settime.mm=0;
			if(g_settime.hh!=23)
				g_settime.hh++;
			else
			{
				g_settime.mm=0;
				g_settime.hh=0;
			}
		}				
	}
	else if(g_underline%3 == HUL)
	{
		if(g_settime.hh != 23 )
		{
			g_settime.hh++;
		}
		else
		{
			g_settime.hh=0;
		}
	}
}

void usartDataJudge(void)
{
	//static u8 i = 1;
	if(g_stopreceive && g_iicsr)
	{
		g_iicsr = 0;
		if( (g_usartrec[0] == 'k') && (g_usartrec[1] == '0') && (g_usartrec[2] == '.') 
			&& (g_usartrec[3] >='1' && (g_usartrec[3] <='9') ))
		{
//			
			USART2_SendString("ok\n");
			IIC24_SendOneData(0, g_usartrec[3]-48);
			Delay_Ms(10);
			g_K = IIC24_RecOneData(0);
			//USART2_SendByte(g_K);
			
			
		}
			
	}

}





//adc.c
#include "includeall.h"
#include "../Driver/ADC/adc.h"

void ADC8_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	ADC_InitTypeDef ADC_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB, ENABLE);
	RCC_ADCCLKConfig(RCC_PCLK2_Div6); 
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	
	ADC_DeInit(ADC1);
	
	ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
	ADC_InitStructure.ADC_ScanConvMode = DISABLE;
	ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
	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_Cmd(ADC1, ENABLE);
	
	/* Enable ADC1 reset calibration register */   
	ADC_ResetCalibration(ADC1);
	/* Check the end of ADC1 reset calibration register */
	while(ADC_GetResetCalibrationStatus(ADC1));
	/* Start ADC1 calibration */
	ADC_StartCalibration(ADC1);
	/* Check the end of ADC1 calibration */
	while(ADC_GetCalibrationStatus(ADC1));
	
}

u16 ADC_Get(u8 ch)
{
	ADC_RegularChannelConfig(ADC1, ch, 1, ADC_SampleTime_55Cycles5);
	
	ADC_SoftwareStartConvCmd(ADC1, ENABLE);
	while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == 0);
	
	return ADC_GetConversionValue(ADC1);
}

u16 ADC_Get_Ave(u8 ch, u8 times)
{
	u8 i = 0;
	u16 value = 0;
	
	for(i=0; i<times; i++)
	{
		value = value + ADC_Get(ch);
		Delay_Ms(5);
	}
	
	return value/times;
}





//rtc.c
#include "includeall.h"
#include "../Driver/RTC/rtc.h"



void RTC_Init(void)
{
	NVIC_InitTypeDef NVIC_InitStructure;
	
	/* Enable PWR and BKP clocks */
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
	/* Allow access to BKP Domain */
	PWR_BackupAccessCmd(ENABLE);
	
	/* Enable the LSI OSC */
	RCC_LSICmd(ENABLE);	
	
	//USART2_SendString("Wait LSI\r\n");
	/* Wait till LSI is ready */
	while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
	{}
	/* Select the RTC Clock Source */
	RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
	/* Enable RTC Clock */
	RCC_RTCCLKCmd(ENABLE);
	/* Wait for RTC registers synchronization */
	RTC_WaitForSynchro();
	/* Wait until last write operation on RTC registers has finished */
	RTC_WaitForLastTask();
		
	NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);	
	
	if (BKP_ReadBackupRegister(BKP_DR1) != 0xA5A4)
	{
		/* Backup data register value is not correct or not yet programmed (when
		   the first time the program is executed) */

		//USART2_SendString("RTC not yet configured....\r\n");

		/* RTC Configuration */		
		/* Reset Backup Domain */
		//BKP_DeInit();

		/* Enable the RTC Second */
		RTC_ITConfig(RTC_IT_SEC|RTC_IT_ALR, ENABLE);

		/* Wait until last write operation on RTC registers has finished */
		RTC_WaitForLastTask();

		/* Set RTC prescaler: set RTC period to 1sec */
		RTC_SetPrescaler(39999);

		/* Wait until last write operation on RTC registers has finished */
		RTC_WaitForLastTask();

		//USART2_SendString("RTC configured....\r\n");

		/* Adjust time by values entered by the user on the hyperterminal */
		Time_Adjust(23, 59, 55);

		BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
	}
	else
	{
		RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP|RCC_APB1Periph_PWR,ENABLE); //RTC是存在后备区域中的，所以是要开启后备区域和电源时钟的
		PWR_BackupAccessCmd(ENABLE);	   //电源控制寄存器(PWR_CR)的BPB位使能对后备区域和RTC的访问
		RCC_RTCCLKCmd(ENABLE);
		//USART2_SendString("No need to configure RTC....\r\n");
		/* Wait for RTC registers synchronization */

		RTC_WaitForSynchro();

		RTC_SetAlarm(Time_Regulate(0, 0, 0));
		/* Enable the RTC Second */
		RTC_ITConfig(RTC_IT_SEC|RTC_IT_ALR, ENABLE);

		/* Wait until last write operation on RTC registers has finished */
		RTC_WaitForLastTask();
		
	}

	//Time_Show();

	//USART2_SendString("RTC end \r\n");
}



uint32_t Time_Regulate(u8 hh, u8 mm, u8 ss)
{
	uint32_t Tmp_HH = 0xFF, Tmp_MM = 0xFF, Tmp_SS = 0xFF;
	
	Tmp_HH = hh;
	
	Tmp_MM = mm;
	
	Tmp_SS = ss;
	

	/* Return the value to store in RTC counter register */
	return((Tmp_HH*3600 + Tmp_MM*60 + Tmp_SS));
}

void Time_Adjust(u8 hh, u8 mm, u8 ss)
{
	/* Wait until last write operation on RTC registers has finished */
	RTC_WaitForLastTask();
	/* Change the current time */
	RTC_SetCounter(Time_Regulate(hh, mm, ss));
	/* Wait until last write operation on RTC registers has finished */
	RTC_WaitForLastTask();
}

void Time_Display(uint32_t TimeVar)
{
	//uint32_t THH = 0, TMM = 0, TSS = 0;
	u8 Time[30];

	/* Reset RTC Counter when Time is 23:59:59 */
	if (RTC_GetCounter() == 0x00015180)//7f变80
	{
	 RTC_SetCounter(0x0);
	 /* Wait until last write operation on RTC registers has finished */
	 RTC_WaitForLastTask();
	}

	/* Compute  hours */
	 g_timtemp.hh = (TimeVar / 3600)<24?(TimeVar / 3600):0;
	/* Compute minutes */
	g_timtemp.mm = (TimeVar % 3600) / 60;
	/* Compute seconds */
	g_timtemp.ss = (TimeVar % 3600) % 60;
	sprintf((char*)Time, "Time: %2d:%2d:%2d\r\n", g_timtemp.hh, g_timtemp.mm, g_timtemp.ss);
}

/**
  * @brief  Shows the current time (HH:MM:SS) on the Hyperterminal.
  * @param  None
  * @retval None
  */   
void Time_Show(void)
{
		
	/* If 1s has been elapsed */
	if (g_TimeDisplay == 1)
	{
	  /* Display current time */
		//USART2_SendString("Time_Display\r\n");
		Time_Display(RTC_GetCounter());
		g_TimeDisplay = 0;
	}	
}

void RTC_IRQHandler(void)
{
	if (RTC_GetITStatus(RTC_IT_SEC) != RESET)
	{
		//USART2_SendString("RTCirq\r\n");
		/* Clear the RTC Second interrupt */
		RTC_ClearITPendingBit(RTC_IT_SEC);

		/* Toggle LED2 */
		//LEDInvert(LED5|LED6);

		/* Enable time update */
		g_TimeDisplay = 1;
		
		/* Wait until last write operation on RTC registers has finished */
		RTC_WaitForLastTask();

	}
	else if(RTC_GetITStatus(RTC_IT_ALR) )
	{
		ReportVoltage();
		RTC_ClearITPendingBit(RTC_IT_ALR);
	}
}





// A code block
IC学习者
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
蓝桥杯嵌入式第七届省赛模拟题-电压测量监控系统，看完这篇保证你蓝桥杯嵌入式赛轻轻松松过省赛。
01-06
蓝桥杯嵌入式第七届模拟题-电压测量监控系统 文章目录蓝桥杯嵌入式第七届模拟题-电压测量监控系统1.题目2.主要思路3.代码实现 1.题目 设计一个电压测量监控设备，定时通过串口向 PC 机发送电压值，通过串口接收系统配 置参数并保存到 E2PROM 中。设备硬件部分主要由电源部分、控制器单元、串口部分、存储 单元组成，系统框图如图 1 所示： 原创文章 2获赞 6访问量 133 关注
第七届蓝桥杯大赛嵌入式设计与开发项目模拟题-电压测量监控设备（试题+源码）
最新发布
05-17
【作品名称】：第七届蓝桥杯大赛嵌入式设计与开发项目模拟题-电压测量监控设备（试题+源码） 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：第七届蓝桥杯大赛嵌入式设计与开发项目模拟题-电压测量监控设备（试题+源码）
蓝桥杯嵌入式第七届程序设计题
m0_73572338的博客
04-02 396
本次的记录是第七届蓝桥杯省赛程序设计题在本次的题目中，除了按键消抖用到一个定时器外，还有测量R37的输出电压，三个LED灯这两个地方需要定时来操作。为了减少定时器的数目，所以我这里只定时了一个0.2秒的定时器，题目中的一秒就采用了计数的方式来实现，也不用一会儿开启一会儿关闭。/**********************************回调函数**********************************/i<4;
第七届蓝桥杯嵌入式省赛模拟题任务书加完整工程，电压测量监控设备
03-28
该资源包含任务书和完整的工程文件，工程是Keil4 MDK工程，与考场使用的都是一样的版本。工程已经完全调试完成并实现了任务书的所有要求，内有大量的注释方便他人阅读
蓝桥杯嵌入式第十四届真题和详解
m0_74676415的博客
04-10 989
在讲解十二届的题目之前，强烈建议去看我上一篇《蓝桥杯嵌入式总结和考前冲刺》，涵盖了各个模块的初始化以及基础配置，相关的思路则在我这一篇，如有某个模块不熟悉，请前往查看。这篇给我最大的感受就是，状态非常的多，特别考察逻辑联系的能力，对设置标志位的能力要求较高，我会将我的答案分享给大家（附解析！！！
【STM32】第七届嵌入式模拟——“电压测量监控设备”(CT117E电路)
码上有的博客
04-09 1231
目录 一、题目 设计任务及要求 二、模块化代码分析 main.c adc.c led.c usart.c _24c02.c key.c stm32f10x_it.c的滴答函数的配置 一、题目 设计一个电压测量监控设备，定时通过串口向 PC 机发送电压值，通过串口接收系统配置参数并保存到 E2PROM 中。设备硬件部分主要由电源部分、控制器单元、串口部分、存储单元组成，系统框图如图 1 所示 ： 设计任务及要求 1...
第七届蓝桥杯嵌入式编程题-----“电压测量监控设备”
a568713197的博客
03-22 2149
第六届的试题还有些bug没有解决，所以先发出第七届的，还是和上次一样，暂时没有讲解。 main.c #include "stm32f10x.h" #include "led.h" #include "lcd.h" #include "eeprom.h" #include "key.h" #include "adc.h" #include "usart.h" #include ...
第七届蓝桥杯嵌入式（省赛）程序题
m0_51095029的博客
05-03 1220
第七届蓝桥杯（省赛）解读+程序解读：这里自己多读几遍设计任务以及要求再看下面`A):先搭总体框架`各初始化函数:`LCD初始化``按键初始化``ADC初始化``i2c初始化``USART2初始化``LED初始化`注：仅展示部分初始化函数，完整程序请下载工程查看`B):LCD处理函数``C):按键处理函数``D):ADC处理函数``E):UART处理函数``F):LED处理函数``G):整体程序设计参考` 解读： 模拟液位检测系统中，实验设计任务要求: 依据实验设计任务，所要用到的片内，.
注意include .h 文件的使用
tina_tian1的博客
09-06 3501
场景： （看到项目中有如下使用方式，觉得会存在弊端，占用不必要的内存，虽然结果没有问题。） 多个变量定义在一个fid.h文件， 多个cpp文件（比如100个）同时#include "fid.h" 弊端： 任意一变量会在cpp文件中展开，如果fid.h被include了100次，任一fid.h中的变量将在可执行文件中定义100次， 之所以链接不会出错重复定义，是因为变量被cons
蓝桥杯单片机学习过程记录（二十六）第七届国赛电压、频率采集设备
爆炒小肥牛
03-08 772
蓝桥杯单片机学习过程记录（二十六）第七届国赛电压、频率采集设备 N555方波这部分没写，准备重新理解一下，其余部分都已经完成，遇到了两个问题，一是时钟芯片，调整时，记得调整完后重新初始化一下，二是采集电压波动时，由正常到高，有正常到低时的判断频率调整一下。 应用的内容： 数码管、矩阵按键、 IIC_Rb2电压采集 EEPROM的写入读取 DS1302时钟芯片 定时器 /* ------------...
蓝桥杯CT117E嵌入式竞赛板省赛第七届代码
12-01
蓝桥杯嵌入式组省赛代码，第七届代码，功能完全实现，文件内附带题目。电压测量监控设备。 蓝桥杯嵌入式组省赛代码，第七届代码，功能完全实现，文件内附带题目。电压测量监控设备。
第七届蓝桥杯-省赛-试题.pdf
08-18
第七届 蓝桥杯省赛试题 单片机 pdf格式。
蓝桥杯单片机项目练习
11-26
蓝桥杯单片机项目练习，大家分享下····· 1.上电显示时间为23时59分55秒，此后时间一直保持行走。（10分）若跳到其他界面，按键按s1后，返回时间界面。（其他界面类似） 2.利用PCF8591模块测量电压，幅值为（0V-5V），按下S2，显示界面为如下图：该界面为电压测量界面（10分） 3．在显示电压界面下，定义s4键为电压阈值调整键，按下s4键之后，循环显示电压上限，下限，对应的单元1s间隔闪烁，定义s6键为“+”，s7为“-”， 每次加减为500mv，再次按下s2键后，返回到电压测量界面，并将阈值存放到AT24c02中，再次上电时要读取上一次值（20分） 4.当测量到信号电压大于上限时，LED灯1s间隔闪烁，蜂鸣器不响；当测量信号小于电压下限时，蜂鸣器响，此时LED熄灭；当信号正常时，LED为呼吸灯状态，蜂鸣器不响。（20分） 5.定义s3键为频率信号测量按键，按下该键后启动频率测量，显示频率测量界面，无论调到什么界面，按下s3后，返回到频率测量界面。此时s4键的功能为频率周期切换功能。（20分） 6.定义s5键为查询键，记录最近的一次电压超出上限或者下限的时间和类型，超出上限记为01，超出下限记为00.此时s4键为切换事件的类型或者时间。（20分）
蓝桥杯嵌入式第七届模拟题-电压测量监控系统.rar
05-01
蓝桥杯嵌入式第七届模拟题-电压测量监控系统，设计一个电压测量监控设备，定时通过串口向 PC 机发送电压值，通过串口接收系统配 置参数并保存到 E2PROM 中。设备硬件部分主要由电源部分、控制器单元、串口部分、存储单元组成，亲测有效
2016_第七届_蓝桥杯_省赛_电压测量监控设备.rar
09-06
2016_第七届_蓝桥杯_省赛_电压测量监控设备！！代码！！ 功能要求全部完成 设计一个电压测量监控设备，定时通过串口向 PC 机发送电压值，通过串口接收系统配 置参数并保存到 E2PROM 中
蓝桥杯单片机第11届-电压采集计数
qq_44106838的博客
01-25 808
矩阵键盘、界面控制、计数功能均采用状态机编写。用状态机的好处就是思路清晰，不需要大量标志位，可以减轻调试的负担。
蓝桥杯单片机第10届-电压频率采集
qq_44106838的博客
02-08 568
题目 main.c #include<stc15f2k60s2.h> #include "intrins.h" #define uchar unsigned char #define s0 0 #define s1 1 int read_vol(); void write_vol(int vol); code uchar semg[13] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90, 0
蓝桥杯（省题）—— 电压
qq_62081970的博客
09-12 479
按键1定义为“切换”按钮，每次按下在数据显示和统计界面切换。按键2为记录按钮，每次按下都会采集当前的电压值并保存，按键2仅在数据界面有效。按键3为清除按键，可以清除电压数据、次数、max等等，按键3仅在数据界面有效。处于数据显示界面时，led1点亮，否则灭。数据显示界面包含三个显示要素：界面名称（Data）、电压值(ADC)、数据保存次数（Total）。数据统计包含四个显示要素：界面名称（Hist）、max、min、avg。扫描三个按键，根据按键执行数据显示、存储和指示灯相关功能。
蓝桥杯嵌入式第十三届省赛
03-27
蓝桥杯嵌入式第十三届省赛是蓝桥杯全国大学生程序设计竞赛的一个分赛事，专门面向嵌入式系统开发领域的大学生。该比赛旨在提高大学生的嵌入式系统设计与开发能力，促进学生对嵌入式技的学习和应用。 比赛内容主要包括个部分：单机编程和嵌入式系统设计。在单片机编方面，参赛选手需要通过编写程序实现特定功能，如控制外设、处理传器数据等。在嵌入式系统设计方面，参赛选手需要根据给定的需求设计并实现一个完整的嵌入式系统，包括硬件设计和软件开发。 蓝桥杯嵌入式第十三届省赛是一个具有挑战性和实践性的比赛，参赛选手需要具备扎实的嵌入式系统开发基础知识和编程技能。通过参加比赛，选手可以提升自己的实践能力、团队协作能力和解决问题的能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值