蓝桥杯嵌入式12届

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

感觉十二届的省赛还是比较难的，特别是对串口接收到的数据进行处理那块。

由于串口接收到的数据都是字符类型，所以需要一些对字符串进行处理的函数


//定义一个结构体数组将车辆的信息都存入其中
typedef struct car_park{
    char type[5];
    char id[5];
    int year;
    int month;
    int day;
    int hour;
    int minute;
    int second;
}car_park;
//定义一个结构体数组，就是其中八车库的数据
typedef struct Parking{
    int can_park;
    int size;
    car_park car_infom;
}Parking[8];

car_park car_buff;

//该函数的功能就是将输入的字符串数组进行解析，将数据存入对应的结构体中，并且判断数据的合法性
int parseString(const char *inpit,car_park *car)
{
    strncpy(car->type,input,4);//strncpy()该函数不会自动加'\0',故需要手动加上
    car->type[4]='\0';
    strncpy(car->id,input+5,4);
    car->id[4]='\0';

    sscanf(input+10,"%2u%2u%2u%2u%2u%2u",&car->year,&car->month,&car->day,
    &car->hour,&car->minute,&car->second);

    memset(input,0,sizeof(input));

    if(strcmp(car->type,"VNBR")!=0 && strcmp(car->type,"CNBR")!=0)
    {
        sprintf((char*)Tx,"ERROR TYPE\n")
        HAL_UART_Transmit(&huart1,Tx,strlen(Tx),50);
        return 0;
    }
    if(car->month>12||car->day>31||
    car->hour>24||car->minute>60||car->second>60)
    {
        sprintf((char*)Tx,"TIME ERROR\n")
        HAL_UART_Transmit(&huart1,Tx,strlen(Tx),50);
        return 0;
    }
    return 1;
}

以上我们实现了对串口数据的解析，例如输入CNBR:R258:201212100000

首先将该字符串存入串口接收数据数组中，然后将字符串解析存入结构体当中，包括车型，车牌，和进出时间。对时间进行解析的函数使用sscanf();如果对该函数不熟悉亦可对字符串减去'0'，化为数字。如果数据不合法则返回0，如果数据合法则返回1，将其存入缓冲数组当中。

将数据解析后就进行入库出库判断,入库函数就是将缓冲数组接收到的数据与车库数组中的信息作比较，如果该车位数组中的can_park标志位为1则代表该车位闲置，然后将缓冲数组中的数据Parking_buff存入车位数组Parking[i]的信息当中

int Park(Parking *Parking,car_park *car_buff)
{
    unsigned char type_flag;
    unsigned char i;
    if(Leisure<=0)
        return 0;

    if(strcmp(car_buff->type,"CNBR")==0)
        type_flag=1;
    if(strcmp(car_buff->type,"VNBR")==0)
        type_flag=2;
    
    for(i=0;i<8;i++)
    {
        if(Parking[i].can_park==1)
        {
            if(type_flag==1)
                CNBR--;
            if(type_flag==2)
                VNBR--
            Leisure--;
            
            strcpr(Parking[i].car_inform.id,car_buff.id);
            strcpr(Parking[i].car_inform.type,car_buff.type);
            Parking[i].car_infom.year=car->year;
            Parking[i].car_infom.month=car->month;
            Parking[i].car_infom.day=car->day;
            Parking[i].car_infom.hour=car->hour;
            Parking[i].car_infom.minute=car->minute;
            Parking[i].car_infom.second=car->second;
            return 1;
        }    
    }
    return 0;
}

出库程序：

double Park_time;
double sum;
//在该示例中，对出库车辆的判断涉及对车费的计算
double goOut(Parking *Parking,car_part car_part,float CNBR_Price,float VNBR_Price)
{
    int i;
    float Price;
    unsigned char type_flag;

    car_part car_old;

    if(strcmp(car_part.type,"CNBR")==0)
    {
        Price=CNBR_Price;
        type_flag=1;
    }
    if(strcmp(car_part.type,"VNBR")==0)
    {
        Price=CNBR_Price;
        type_flag=2;
    }
    //对Paeking数组进行遍历，如果发现相同车牌号，则计算时间价格后出库
    for(i=0;i<8;i++)
    {
        car_old=Parking.car_infrom;
        if(strcmp(car_part.id,car_old.id)==0)
        {
            if(type_flag==1)
            {
                Leisure++;
                CNBR--;
            }
             if(type_flag==2)
            {
                Leisure++;
                VNBR--;
            }
            Park_time=(car_part.year-car_old.year)*365*24+
            (car_part.month-car_old.month)*30*24
                +(car_part.day-car_old.day)*24;

            if(Park_time<0)
                return -2;//时间不合法
            else if(Park_time==0)
            {
                if(((car_part.minute+car_part.hour*60)-
                        (car_old.minute+car_old.hour*60))<0)
                    return -2;//时间不合法
                else
                {
                    return Price;
                    Init_park(Parking,i);
                }
            }
            else
            {
                Init_park(Parking,i);
                sum=Price*Park_time;
                return sum;
            }
        }
    }
    return -1;
}
unsigned char isRxCaplt(void)
{
	if(Rx_point!=22)
		return 0;
	if(((Rx[0]=='C')||(Rx[0]=='V'))&&(Rx[1]=='N')&&
		(Rx[2]=='B')&&(Rx[3]=='R')&&(Rx[4]==':')&&(Rx[9]==':'))
	{
		unsigned char i;
		for(i=0;i<22;i++)
		{
			if((Rx[i]>'9')&&(Rx[i]<'0'))
				return 0;
		}
		return 1;
	}
}
void UART_Proc(void)
{
	if(uwTick-UART_tick<100) return;
	UART_tick=uwTick;
	
	if(isRxCaplt())
	{
		parseString(Rx,&car_buff);
		sum=goout(park_inf,car_buff,C_price,V_price);
		if(sum==-1.0)
		{
			if(park(park_inf,&car_buff)==1)
			{
				sprintf((char*)Rx,"Success Park\n");
				HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
			}
			else if(park(park_inf,&car_buff)==0)
			{
				sprintf((char*)Rx,"Error Park\n");
				HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
//				sprintf((char*)Rx,"Success Park\n");
//				HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
			}
		}
		
		if(sum==-2)
		{
			sprintf((char*)Rx,"Error Parktime\n");
			HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
		}
		
		if(sum>=0)
		{
			sprintf((char*)Rx,"%s:%s:%dhour:%.0f$\n",car_buff.id,car_buff.type,park_time,sum);
			HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
		}
		Rx_point=0;
	}

}

所有代码汇总

__IO uint32_t Key_tick,Lcd_tick,Led_tick,UART_tick;
//key
unsigned char Key_value,Key_old,Key_down,Key_up;
//lcd
unsigned char Page=1;
unsigned char String_[20];
unsigned char CNBR=0,VNBR=0;
unsigned char Leisure=8;//¿ÕÏÐÊýÄ¿
float C_price=3.5,V_price=2.0;
//pwm
unsigned char Pwm_mode;
//uart
int park_time;
double sum;
unsigned char Rxdata;
unsigned char Rx_point;
unsigned char Rx[30];
unsigned char Tx[30];

typedef struct {
	 char type[5];
	 char id[5];
	 int year;
	 int month;
	 int day;
	 int hour;
	 int minute;
	 int second;
}car_part;

typedef struct {
	car_part car_inf;
	int size;
	int can_park;
}Parking;



car_part car_buff;
Parking parking;
Parking park_inf[8];

void Lcd_proc(void);
void Key_proc(void);
void Led_proc(void);
void UART_Proc(void);
void Initpart(Parking* parking,int location);
unsigned char isRxCaplt(void);
double goout(Parking* parking,car_part car,float cnbr_price,float vnbr_price);
int  park(Parking* parking,car_part* car);
void Init_park(void);
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM3_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
  LCD_Init();
  LCD_Clear(Black);
  LCD_SetBackColor(Black);
  LCD_SetTextColor(White);
  
  Initpart(park_inf,8);
  
  HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_2);
  __HAL_TIM_SetCompare(&htim3,TIM_CHANNEL_2,0);
  
 HAL_UART_Receive_IT(&huart1,&Rxdata,1);
 
 Init_park();

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
	  Lcd_proc();
	  Key_proc();
	  Led_proc();
	  UART_Proc();
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	Rx[Rx_point++]=Rxdata;
	HAL_UART_Receive_IT(&huart1,&Rxdata,1);
}

unsigned char isRxCaplt(void)
{
	if(Rx_point!=22)
		return 0;
	if(((Rx[0]=='C')||(Rx[0]=='V'))&&(Rx[1]=='N')&&
		(Rx[2]=='B')&&(Rx[3]=='R')&&(Rx[4]==':')&&(Rx[9]==':'))
	{
		unsigned char i;
		for(i=0;i<22;i++)
		{
			if((Rx[i]>'9')&&(Rx[i]<'0'))
				return 0;
		}
		return 1;
	}
}

void UART_Proc(void)
{
	if(uwTick-UART_tick<100) return;
	UART_tick=uwTick;
	
	if(isRxCaplt())
	{
		parseString(Rx,&car_buff);
		sum=goout(park_inf,car_buff,C_price,V_price);
		if(sum==-1.0)
		{
			if(park(park_inf,&car_buff)==1)
			{
				sprintf((char*)Rx,"Success Park\n");
				HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
			}
			else if(park(park_inf,&car_buff)==0)
			{
				sprintf((char*)Rx,"Error Park\n");
				HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
//				sprintf((char*)Rx,"Success Park\n");
//				HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
			}
		}
		
		if(sum==-2)
		{
			sprintf((char*)Rx,"Error Parktime\n");
			HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
		}
		
		if(sum>=0)
		{
			sprintf((char*)Rx,"%s:%s:%dhour:%.0f$\n",car_buff.id,car_buff.type,park_time,sum);
			HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
		}
		Rx_point=0;
	}

}


int parseString(const char *input,car_part *car)
{
	strncpy(car->type,input,4);//strncpy²»»á×Ô¶¯¼ÓÉÏÖÕÖ¹·û£¬¹ÊÐèÒªÊÖ¶¯¼ÓÉÏ
	car->type[4]='\0';
	strncpy(car->id,input+5,4);
	car->id[4]='\0';
	
	sscanf(input+10,"%2u%2u%2u%2u%2u%2u",&car->year, &car->month, &car->day, 
	&car->hour, &car->minute, &car->second);
	
	memset(Rx,0,sizeof(Rx));
	
	if(strcmp(car->type,"VNBR")!=0&&strcmp(car->type,"CNBR")!=0)
	{
		sprintf((char*)Rx,"Error Type Format\n");
		HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
		return 0;
	}
	else if(car->month>12||car->day>31||car->hour>24||car->minute>60||car->second>60)
	{
		sprintf((char*)Rx,"Time Format\n");
		HAL_UART_Transmit(&huart1,Rx,strlen(Rx),50);
		return 0;
	}
	else
		return 1;
}

int park(Parking* parking,car_part* car)//1 Í£³µÍê³É 0 ûÓпÕλ 
{
	unsigned char i=0;
	unsigned char type_flag;
	
	if(Leisure<=0)
	{
		return 0;
	}
	
	if(strcmp(car->type,"CNBR")==0)
		type_flag=1;
	if(strcmp(car->type,"VNBR")==0)
		type_flag=2;
	
	for(i=0;i<8;i++)
	{
		if(parking[i].can_park==1)
		{
			if(type_flag==1)
			{
				CNBR++;
				Leisure--;
			}
			if(type_flag==2)
			{
				VNBR++;
				Leisure--;
			}
			
			strcpy(parking[i].car_inf.id,car->id);
			strcpy(parking[i].car_inf.type,car->type);
			parking[i].car_inf.year=car->year;
			parking[i].car_inf.month=car->month;
			parking[i].car_inf.day=car->day;
			parking[i].car_inf.hour=car->hour;
			parking[i].car_inf.minute=car->minute;
			parking[i].car_inf.second=car->second;
			parking[i].can_park=0;
			return 1;
		}
	}
	return 0;
}

double goout(Parking* parking,car_part car,float cnbr_price,float vnbr_price)
{
	int i=0;
	float price;
	unsigned char type_flag;
	
	car_part oldcar;
	
	if(strcmp(car.type,"CNBR")==0)
	{
		price=cnbr_price;
		type_flag=1;
	}
	if(strcmp(car.type,"VNBR")==0)
	{
		price=vnbr_price;
		type_flag=2;
	}
	
	for(i=0;i<8;i++)
	{
		oldcar=parking[i].car_inf;
		if(parking[i].can_park==1)
		{
			continue;
		}
		
		if(strcmp(oldcar.id,car.id)==0)
		{
			if(type_flag==1)
			{
				CNBR--;
				Leisure++;
			}
			if(type_flag==2)
			{
				VNBR--;
				Leisure++;
			}
			
			park_time=(car.year-oldcar.year)*365*24+
			(car.month-oldcar.month)*30*24+
			(car.hour-oldcar.hour);
			
			if(park_time<0)
			{
				park_time=0;
				return -2;
			}
			else if(park_time==0)
			{
				if(((car.minute*60+car.second)-(oldcar.minute*60+oldcar.second))<0)
				{
					return -2;
				}
				else
				{
					Initpart(parking,i);
					return price;
				}
			}
			else
			{
				strcpy(parking[i].car_inf.id,"     ");
				strcpy(parking[i].car_inf.id,"     ");
				parking[i].car_inf.year=0;
				parking[i].car_inf.month=0;
				parking[i].car_inf.day=0;
				parking[i].car_inf.hour=0;
				parking[i].car_inf.minute=0;
				parking[i].car_inf.second=0;
				parking[i].can_park=1;
				sum=price*(float)park_time;
			}
			
			return sum;
		}
	}
	return -1;
}

void Initpart(Parking* parking,int location)
{
	for(location=0;location<8;location++)
	{
		strcpy(parking[location].car_inf.id,"     ");
		strcpy(parking[location].car_inf.id,"     ");
		parking[location].car_inf.year=0;
		parking[location].car_inf.month=0;
		parking[location].car_inf.day=0;
		parking[location].car_inf.hour=0;
		parking[location].car_inf.minute=0;
		parking[location].car_inf.second=0;
		parking[location].can_park=1;
	}
	return;
}

void Init_park(void)
{
	park_inf[0].can_park=1;
	park_inf[1].can_park=1;
	park_inf[2].can_park=1;
	park_inf[3].can_park=1;
	park_inf[4].can_park=1;
	park_inf[5].can_park=1;
	park_inf[6].can_park=1;
	park_inf[7].can_park=1;
}

void Lcd_proc(void)
{
	if(uwTick-Lcd_tick<50) return;
	Lcd_tick=uwTick;
	
	if(Page==1)
	{
		sprintf((char*)String_,"      Data");
		LCD_DisplayStringLine(Line1,String_);
		sprintf((char*)String_,"   CNBR:%d",CNBR);
		LCD_DisplayStringLine(Line3,String_);
		sprintf((char*)String_,"   VNBR:%d",VNBR);
		LCD_DisplayStringLine(Line5,String_);
		sprintf((char*)String_,"   IDLE:%d",Leisure);
		LCD_DisplayStringLine(Line7,String_);
	}
	else if(Page==2)
	{
		sprintf((char*)String_,"      Para");
		LCD_DisplayStringLine(Line1,String_);
		sprintf((char*)String_,"   CNBR:%3.2f",C_price);
		LCD_DisplayStringLine(Line3,String_);
		sprintf((char*)String_,"   VNBR:%3.2f",V_price);
		LCD_DisplayStringLine(Line5,String_);
	}
	
		sprintf((char*)String_,"  pwm_mode:%d",Pwm_mode);
		LCD_DisplayStringLine(Line2,String_);
}

void Key_proc(void)
{
	if(uwTick-Key_tick<50) return;
	Key_tick=uwTick;
	
	Key_value=Key_scan();
	Key_down=Key_value&(Key_value^Key_old);
	Key_up=~Key_value&(Key_value^Key_old);
	
	Key_old=Key_value;
	
	if(Key_down==1)
	{
		LCD_Clear(Black);
		if(Page==1)
			Page=2;
		else if(Page==2)
			Page=1;
	}
	else if(Key_down==2)
	{
		if(Page==2)
		{
			C_price+=0.5;
			V_price+=0.5;
		}
	}
	else if(Key_down==3)
	{
		if(Page==2)
		{
			C_price-=0.5;
			V_price-=0.5;
			if(C_price<=0)
				C_price=0;
			if(V_price<=0)
				V_price=0;
		}
	}
	else if(Key_down==4)
	{
		if(Pwm_mode)
		{
			__HAL_TIM_SetCompare(&htim3,TIM_CHANNEL_1,0);
			Pwm_mode=0;
		}
		else
		{
			__HAL_TIM_SetCompare(&htim3,TIM_CHANNEL_1,299);
			Pwm_mode=1;
		}
	}
}

unsigned char lednum;
void Led_proc(void)
{
	if(uwTick-Led_tick<100) return;
	Led_tick=uwTick;
	
	if(Leisure)
		lednum|=0x01;
	else
		lednum&=0xfe;
	
	if(Pwm_mode)
		lednum|=0x02;
	else
		lednum&=0xfd;
	
	Led_disp(lednum);
}

chenyuyuyuz
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
12届蓝桥杯嵌入式设计与开发大学组参赛经验
nop_____的博客
06-09 1497
12届蓝桥杯嵌入式设计与开发大学组参赛经验 本人今年大三第一次参加蓝桥杯比赛，报的是电子类嵌入式组，比完等了两天，直到昨天晚上出成绩获得了湖南赛区一等奖，全国三奖。以下便是我参赛的全部经验： 1.首先报这个比赛之前我就在学长那了解过这个比赛，然后再是上百度，知乎了解了含金量。看网上有人说蓝桥杯就是圈钱杯或者说没什么用，而我觉得一个比赛有没有用不是针对所有人来说的，要看这个比赛对你自己而言有没有什么作用。就我学长而言，我的上上届学长就是我们学校唯一一个参加第10届蓝桥杯嵌入式组的学生，当时他一个人参加初赛然后
第十二届蓝桥杯
weixin_52138829的博客
04-20 1738
第十二届蓝桥杯1.空间题目知识点思路代码 1.空间 题目 小蓝准备用 256MB 的内存空间开一个数组，数组的每个元素都是 32 位 二进制整数，如果不考虑程序占用的空间和维护内存需要的辅助空间，请问 256MB 的空间可以存储多少个 32 位二进制整数？ 知识点 计算机中存储单位 最小是位 <其次字节(byte)<KB<MB<GB<TB 1B（byte，字节）= 8 （bit，位）； 1KB=1024B(字节) 1MB=1024KB 1GB=1024MB 1TB=1024G
【蓝桥杯】蓝桥杯嵌入式——题目总结及文章汇总（内含客观题与主观题，并且都附有详细题解）
m0_53958256的博客
06-07 8636
蓝桥杯历年赛题题解
十一届蓝桥杯嵌入式——心得
徐真天的小小锦囊
01-19 8516
第十一届蓝桥杯嵌入式总结 11月14号决赛比完，15号就出成绩了。这速度真的很快。（不过官方发放获奖证书的速度要有这么快就好了，小小的吐槽一下） 心得： 决赛结果还不错，国赛一等奖。也算是对得起我大半年的努力。 没有容易的事，疫情的影响，比赛也是从上半年三月份拖到了下半年10月份。在中途很多人都退钱放弃了这个比赛。*（我学校是这样） 不过大家既然报了名，就要认真去对待他。在寒假的时候把省赛的各个模块都给学完，然后是做了两三套省赛题。在三月份之前，我怕还会比赛，我就把自己学过的复习了一遍。但是延期了，在九月份
2024年蓝桥杯嵌入式比赛的准备心得和比赛资源注意事项（附赛事资源包）
m0_74069066的博客
02-27 4126
蓝桥杯嵌入式组比赛最主要考验的是对于stm32相关方面的编程能力，以及选择填空方面的电子学科基础知识和对硬件的了解，和其它赛道的纯软方向不同，电子类单片机组和嵌入式组更加偏向硬件，要求参赛者具备数电模电、ARM Cortex M4硬件资源和软件编程与调试等知识。当然这对于大一新生自然是有难度的，因为有些学校大一上学期并不开设数电模电课程，需要自学相关内容，好在考察并不是很深入。
蓝桥杯嵌入式真题试水（一）——2021
qq_51406846的博客
03-29 1033
关于蓝桥杯嵌入式2021年真题的一些个人理解！
第十二届蓝桥杯参赛感悟
m0_57246577的博客
05-03 563
参加第十二届蓝桥杯 C/C++ 省赛后体会和总结 一、蓝桥杯省赛小试牛刀 此文章用以纪念我第一次参加蓝桥杯省赛后的体会和感想。 2021年省赛蓝桥杯的考场地点是武汉商学院。2021年4月18日9点，我怀着一丝激动的心情走进了蓝桥杯考试场，第一次和众多的学霸们同场竞技，我还真的有点紧张了，但不怕，做好自己就是最好的啦。 虽然我最后没有得奖，但我会继续努力，在这次失败的道路上总结经验。 二、题目解题及分析 第一题：就是计算ASCII码的值，在这里就不细说了。 ASCII编译表（取片段，供参考）
【蓝桥杯嵌入式】第十二届蓝桥杯嵌入式国赛程序设计题
03-01
【蓝桥杯嵌入式】第十二届蓝桥杯嵌入式国赛程序设计题
第十五届蓝桥杯嵌入式省赛真题解析
04-13
在第十五届蓝桥杯嵌入式省赛中，参赛者们可能面临的是对这类系统的理论理解与实践操作的挑战。嵌入式系统广泛应用于各个行业，如消费电子、医疗设备、工业自动化、汽车电子等，其核心在于高效、低功耗、实时性强和...
蓝桥杯嵌入式13届省赛题
06-01
"蓝桥杯嵌入式13届省赛题"是一个针对嵌入式系统设计与开发的比赛，主要考察参赛者的综合技能，包括硬件基础、软件编程、系统集成等。该比赛对于提升学生和工程师在职场和发展中的竞争力具有重要意义，因为嵌入式技术...
蓝桥杯大赛嵌入式组经验总结思路图
01-04
蓝桥杯比赛、STM32F103学习
蓝桥杯嵌入式项目资源包
01-16
省赛比赛时，官方会提供的资源包。主要有：3.5版本的固件库，i2c的参考程序，各个芯片的数据手册，液晶屏参考例程，竞赛板原理图，驱动及插件，串口等备用工具。
第十五届蓝桥杯嵌入式省赛真题题目和答案
最新发布
04-13
第十五届蓝桥杯嵌入式省赛真题题目和答案
蓝桥杯嵌入式第七届试卷及答案
02-19
在"蓝桥杯嵌入式第七届试卷及答案"中，我们可以预见到试题会涵盖以下几个方面的知识点： 1. **嵌入式处理器**：包括微控制器（MCU）和数字信号处理器（DSP）等，它们在嵌入式系统中扮演核心角色，控制整个系统的...
第十四届蓝桥杯嵌入式赛后总结
qq_61957591的博客
05-07 1476
第十四届蓝桥杯嵌入式大赛已经结束，成绩也已经出来了，如所愿，赛区一等奖，那么今天做一下嵌入式赛题的总结。同时这也是我第一次使用markdown文本编辑器来进行编写文档。
蓝桥杯嵌入式——第十届蓝桥杯嵌入式国赛
FILWY_M
05-22 5669
蓝桥杯嵌入式——第十届蓝桥杯嵌入式国赛 目录蓝桥杯嵌入式——第十届蓝桥杯嵌入式国赛一、赛题二、CubeMX模块配置三、部分模块代码四、完整代码下载 一、赛题 上一次做了第十一届的国赛赛题，感觉很容易。然后这两天做了第十届的赛题，感觉第十届的赛题是十一届难度的两倍。这一届的赛题考察的内容特别多，并且逻辑方面相比十一届也是难度大一些的，所以正式比赛的时候，如果不是特别熟悉，还有可能不能把全部的功能都实现。这一届考察的内容大致如下： LED LCD，LCD的高亮显示 独立按键，长按 双通道
蓝桥杯嵌入式——第十二届蓝桥杯嵌入式国赛
热门推荐
FILWY_M
06-10 1万+
蓝桥杯嵌入式——第十一届蓝桥杯嵌入式国赛 之前准备省赛的时候用的是旧版的STM32F103，从准备国赛开始就用新版STM32G431平台了，主要是想经过新版的准备学习一下HAL库以及CubeMX的使用。用了几天的新版，感觉新版的还是比较香，单纯从配置各个模块来说，比旧版的省太多时间了，而且速度也比较块，单纯从比赛来说，还是推荐新版，因为配置方便，调试器兼容KEIL5，KEI5比KEIL4好用太多了，也有自动补全，在写代码的时候速度也会比较快一些。不过旧版的资料确实比较多，选择也看大家。所以之后的国赛赛题都
谈谈蓝桥杯嵌入式国赛感受
weixin_43175983的博客
06-05 3451
参加了两次蓝桥杯，一次单片机组，一次嵌入式组。 趁着今年嵌入式国赛刚结束，谈谈感受。 赛前觉得准备的已经很充分了，但考场顺应万变，一些情况完全不是自己能想得到的。 嵌入式环境是需要现场安装的，所以，笔者也是提前进入了考场。环境装完了，松了一口气。结果登录IP地址的时候出现问题了，登录不上去，无奈，只能换电脑，耽误了很长时间。 比赛前，进入考场，一些问题，一定要提前想到。例如，考场的资源包，可能由于布置考场的人员疏忽，资源包就有个别电脑没有。所以，步入考场，一定要先检查环境，配置，资源包。没有的话，一定要联系
蓝桥杯嵌入式真题试水（三）——2019
qq_51406846的博客
04-03 4735
蓝桥杯嵌入式真题试水2019
蓝桥杯嵌入式十二届模拟
04-09
蓝桥杯嵌入式十二届模拟是蓝桥杯嵌入式大赛的一次模拟赛。蓝桥杯嵌入式大赛是由中国教育部主办的全国性大学生计算机竞赛，旨在培养和选拔优秀的嵌入式系统开发人才。比赛内容主要包括嵌入式系统设计与开发、单片机...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值