蓝桥杯嵌入式2023年第十四届省赛主观题解析

1  题目

2  代码

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "adc.h"
#include "rtc.h"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdio.h"
#include "string.h"
#include "lcd.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
double v;
char buf1[20],buf2[20],buf3[20],buf4[20],buf5[20],buf6[20],buf7[20],buf8[20],buf9[20],buf10[20],buf11[20],buf12[20],buf13[20];
struct keys{
	int state;
	int step;
	int cnt;
	int cnt2;
}key[5];
double f=250,duty=0.2;
int N;
uint32_t OCcnt=0;
int state;
int start,end,R=1,K=1,TR=1,TK=1;
double V,f7,cnt,hmax,lmax;
int time,SR;
RTC_TimeTypeDef sTime = {0};
RTC_DateTypeDef sDate = {0};
RTC_AlarmTypeDef sAlarm = {0};
/* 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 */
void getADC()
{
	HAL_ADC_Start(&hadc2);
	v=HAL_ADC_GetValue(&hadc2)*3.3/4096;
}
void LED_Close()
{
	HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
	HAL_GPIO_WritePin(GPIOC,GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15,GPIO_PIN_SET);
	HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
}
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance==TIM3&&htim->Channel==HAL_TIM_ACTIVE_CHANNEL_2)
	{
		cnt=HAL_TIM_ReadCapturedValue(&htim3,TIM_CHANNEL_2);
		f7=1000000/cnt;
		__HAL_TIM_SetCounter(&htim3,0);
		HAL_TIM_IC_Start_IT(&htim3,TIM_CHANNEL_1);
	}
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance==TIM1)
	{
		key[1].state=HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_0);
		key[2].state=HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1);
		key[3].state=HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_2);
		key[4].state=HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0);
		switch(key[1].step)
		{
			case 0:
			{
				if(key[1].state==GPIO_PIN_RESET)
				{
					key[1].step=1;
				}
			}
			break;
			case 1:
			{
				if(key[1].state==GPIO_PIN_RESET)
				{
					key[1].step=2;
					key[1].cnt++;
					LCD_Clear(White);
					if(key[1].cnt%3==0)
					{
						LCD_DisplayStringLine(Line1,(uint8_t*)buf1);
						LCD_DisplayStringLine(Line3,(uint8_t*)buf2);
						LCD_DisplayStringLine(Line4,(uint8_t*)buf3);
						LCD_DisplayStringLine(Line5,(uint8_t*)buf4);
					}
					if(key[1].cnt%3==1)
					{
						LCD_DisplayStringLine(Line1,(uint8_t*)buf5);
						LCD_SetBackColor(Green);
						LCD_ClearLine(Line3);
						LCD_DisplayStringLine(Line3,(uint8_t*)buf6);
						LCD_SetBackColor(White);
						LCD_DisplayStringLine(Line4,(uint8_t*)buf7);
					}
					if(key[1].cnt%3==2)
					{
						LCD_DisplayStringLine(Line1,(uint8_t*)buf8);
						LCD_DisplayStringLine(Line3,(uint8_t*)buf9);
						LCD_DisplayStringLine(Line4,(uint8_t*)buf10);
						LCD_DisplayStringLine(Line5,(uint8_t*)buf11);
					}
				}
				else
				{
					key[1].step=0;
				}
			}
			break;
			case 2:
			{
				if(key[1].state==GPIO_PIN_SET)
				{
					key[1].step=0;
				}
			}
			break;
		}
		
		switch(key[2].step)
		{
			case 0:
			{
				if(key[2].state==GPIO_PIN_RESET&&key[1].cnt%3!=2)
				{
					key[2].step=1;
				}
			}
			break;
			case 1:
			{
				if(key[2].state==GPIO_PIN_RESET)
				{
					key[2].step=2;
					if(key[1].cnt%3==0)
					{
						if(state==1)
						{
							end=uwTick;
							if(end-start>=1000*5)
							{
								state=0;
							}
						}
						if(state==0)
						{
							key[2].cnt++;
							
						}
					}
					if(key[1].cnt%3==1)
					{
						key[2].cnt2++;
					}
				}
				else
				{
					key[2].step=0;
				}
			}
			break;
			case 2:
			{
				if(key[2].state==GPIO_PIN_SET)
				{
					key[2].step=0;
				}
			}
			break;
		}
		
		switch(key[3].step)
		{
			case 0:
			{
				if(key[3].state==GPIO_PIN_RESET)
				{
					key[3].step=1;
				}
			}
			break;
			case 1:
			{
				if(key[3].state==GPIO_PIN_RESET)
				{
					key[3].step=2;
					if(key[2].cnt2%2==0)
					{
						TR++;
						if(TR>10) TR=1;
						sprintf(buf6,"     R=%d",TR);
						LCD_ClearLine(Line3);
						LCD_DisplayStringLine(Line3,(uint8_t*)buf6);
					}
					else
					{
						TK++;
						if(TK>10) TK=1;
						sprintf(buf7,"     K=%d",TK);
						LCD_ClearLine(Line4);
						LCD_DisplayStringLine(Line4,(uint8_t*)buf7);
					}
				}
				else
				{
					key[3].step=0;
				}
			}
			break;
			case 2:
			{
				if(key[3].state==GPIO_PIN_SET)
				{
					key[3].step=0;
				}
			}
			break;
		}
		if(key[1].cnt%3==1)
		{
			switch(key[4].step)
			{
				case 0:
				{
					if(key[4].state==GPIO_PIN_RESET)
					{
						key[4].step=1;
					}
				}
				break;
				case 1:
				{
					if(key[4].state==GPIO_PIN_RESET)
					{
						key[4].step=2;
						if(key[2].cnt2%2==0)
						{
							TR--;
							if(TR<=0) TR=10;
							sprintf(buf6,"     R=%d",TR);
							LCD_ClearLine(Line3);
							LCD_DisplayStringLine(Line3,(uint8_t*)buf6);
						}
						else
						{
							TK--;
							if(TK<=0) TK=10;
							sprintf(buf7,"     K=%d",TK);
							LCD_ClearLine(Line4);
							LCD_DisplayStringLine(Line4,(uint8_t*)buf7);
						}
					}
					else
					{
						key[4].step=0;
					}
				}
				break;
				case 2:
				{
					if(key[4].state==GPIO_PIN_SET)
					{
						key[4].step=0;
					}
				}
				break;
			}
		}
		if(key[1].cnt%3==0)
		{
			switch(key[4].step)
			{
				case 0:
				{
					if(key[4].state==GPIO_PIN_RESET)
					{
						key[4].step=1;
						time=0;
					}
				}
				break;
				case 1:
				{
					if(key[4].state==GPIO_PIN_RESET)
					{
						key[4].step=2;
					}
					else
					{
						key[4].step=0;
					}
				}
				break;
				case 2:
				{
					if(key[4].state==GPIO_PIN_RESET)
					{
						time++;
					}
					if(key[4].state==GPIO_PIN_SET)
					{
						if(time>200)
						{
							SR=1;
						}
						else
						{
							SR=0;
						}
						key[4].step=0;
					}
				}
				break;
			}
		}
	}
	if(htim->Instance==TIM4)
	{
		V=f7*2*3.14*R/100/K;
		sprintf(buf4,"     V=%.1lf",V);
		sprintf(buf3,"     P=%.0lf%%",duty*100);
		if(key[1].cnt%3==0)
		{
			LCD_ClearLine(Line4);
			LCD_ClearLine(Line5);
			LCD_DisplayStringLine(Line5,(uint8_t*)buf4);
			LCD_DisplayStringLine(Line4,(uint8_t*)buf3);
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
			HAL_GPIO_WritePin(GPIOC,GPIO_PIN_8,GPIO_PIN_RESET);
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
		}
		if(key[1].cnt%3!=0)
		{
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
			HAL_GPIO_WritePin(GPIOC,GPIO_PIN_8,GPIO_PIN_SET);
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
		}
		if(key[1].cnt%3!=1)
		{
			R=TR;
			K=TK;
			key[2].cnt2=0;
		}
		if(key[2].cnt%2==0)
		{
			if(V>lmax)
			{
				lmax=V;
				sprintf(buf11,"     NL=%.1lf",lmax);
			}
		}
		if(key[2].cnt%2==1)
		{
			if(V>hmax)
			{
				hmax=V;
				sprintf(buf10,"     NH=%.1lf",hmax);
			}
		}
		if(key[1].cnt%3==2)
		{
			LCD_ClearLine(Line3);
			LCD_ClearLine(Line4);
			LCD_ClearLine(Line5);
			LCD_DisplayStringLine(Line5,(uint8_t*)buf11);
			LCD_DisplayStringLine(Line4,(uint8_t*)buf10);
			LCD_DisplayStringLine(Line3,(uint8_t*)buf9);
		}
		if(SR==1)
		{
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
			HAL_GPIO_WritePin(GPIOC,GPIO_PIN_10,GPIO_PIN_RESET);
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
		}
		else
		{
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
			HAL_GPIO_WritePin(GPIOC,GPIO_PIN_10,GPIO_PIN_SET);
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
		}
		if(key[1].cnt%3==1)
		{
			LCD_ClearLine(Line3);
			LCD_ClearLine(Line4);
			LCD_SetBackColor(Green);
			if(key[2].cnt2%2==0)
			{
				LCD_ClearLine(Line3);
				LCD_DisplayStringLine(Line3,(uint8_t*)buf6);
				LCD_SetBackColor(White);
				LCD_DisplayStringLine(Line4,(uint8_t*)buf7);
			}
			else
			{
				LCD_ClearLine(Line4);
				LCD_DisplayStringLine(Line4,(uint8_t*)buf7);
				LCD_SetBackColor(White);
				LCD_DisplayStringLine(Line3,(uint8_t*)buf6);
			}
		}
	}
	if(htim->Instance==TIM6)
	{
		if(f>125&&f<250)
		{
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
			HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_9);
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
		}
		else
		{
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
			HAL_GPIO_WritePin(GPIOC,GPIO_PIN_9,GPIO_PIN_SET);
			HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
		}
	}
}
void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance==TIM2&&htim->Channel==HAL_TIM_ACTIVE_CHANNEL_2)
	{
		OCcnt=__HAL_TIM_GetCompare(&htim2,TIM_CHANNEL_2);
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1)==GPIO_PIN_RESET)
		{
			__HAL_TIM_SetCompare(&htim2,TIM_CHANNEL_2,OCcnt+f*(1-duty));
		}
		else
		{
			__HAL_TIM_SetCompare(&htim2,TIM_CHANNEL_2,OCcnt+f*duty);
		}
	}
}
void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{
	HAL_RTC_GetDate(hrtc,&sDate,RTC_FORMAT_BIN);
	HAL_RTC_GetTime(hrtc,&sTime,RTC_FORMAT_BIN);
	
	sprintf(buf13,"   TIME:%02d-%02d-%02d",sTime.Hours,sTime.Minutes,sTime.Seconds);
	sprintf(buf12,"   DATE:%02d-%02d-%02d",sDate.Year,sDate.Month,sDate.Date);
	LCD_ClearLine(Line8);
	LCD_ClearLine(Line9);
	LCD_DisplayStringLine(Line8,(uint8_t*)buf13);
	LCD_DisplayStringLine(Line9,(uint8_t*)buf12);
}
/* 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_TIM1_Init();
  MX_TIM2_Init();
  MX_ADC2_Init();
  MX_TIM3_Init();
  MX_TIM4_Init();
  MX_RTC_Init();
  MX_TIM6_Init();
  /* USER CODE BEGIN 2 */
	LCD_Init();
	LED_Close();
	LCD_Clear(White);
	LCD_SetBackColor(White);
	LCD_SetTextColor(Black);
	HAL_TIM_Base_Start_IT(&htim1);
	HAL_TIM_Base_Start_IT(&htim4);
	HAL_TIM_Base_Start_IT(&htim6);
	HAL_TIM_OC_Start_IT(&htim2,TIM_CHANNEL_2);
	HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_2);
	HAL_TIM_IC_Start_IT(&htim3,TIM_CHANNEL_2);
	HAL_TIM_IC_Start_IT(&htim3,TIM_CHANNEL_1);
	__HAL_TIM_SetCompare(&htim2,TIM_CHANNEL_2,500);
	sprintf(buf1,"        DATA");
	sprintf(buf2,"     M=L");
	sprintf(buf8,"        RECD");
	sprintf(buf5,"        PARA");
	sprintf(buf6,"     R=1");
	sprintf(buf7,"     K=1");
	sprintf(buf10,"     NH=0.0");
	LCD_DisplayStringLine(Line1,(uint8_t*)buf1);
	LCD_DisplayStringLine(Line3,(uint8_t*)buf2);
	LCD_DisplayStringLine(Line4,(uint8_t*)buf3);
	LCD_DisplayStringLine(Line5,(uint8_t*)buf4);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		getADC();
		if(SR==0)
		{
			if(v>=1&&v<=3) duty=0.375*v-0.275;
			if(v<1) duty=0.1;
			if(v>3) duty=0.85;
		}
		if(key[1].cnt%3==0&&key[2].cnt%2==1&&state==0)
		{
			N++;
			state=1;
			start=uwTick;
			for(int i=4000;i<=8000;i+=100)
			{
				f=1000000/i;
				HAL_Delay(100);
			}
			sprintf(buf2,"     M=H");
			LCD_ClearLine(Line3);
			LCD_DisplayStringLine(Line3,(uint8_t*)buf2);
		}
		if(key[1].cnt%3==0&&key[2].cnt%2==0&&key[2].cnt>0&&state==0)
		{
			N++;
			state=1;
			start=uwTick;
			for(int i=8000;i>=4000;i-=100)
			{
				f=1000000/i;
				HAL_Delay(100);
			}
			sprintf(buf2,"     M=L");
			LCD_ClearLine(Line3);
			LCD_DisplayStringLine(Line3,(uint8_t*)buf2);
		}
		sprintf(buf9,"     N=%d",N);
  }
  /* USER CODE END 3 */
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/531540.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

可在手机上运行的2B LLMs ,看看斯坦福大学的这个项目

可在手机上运行的2B LLMs ,看看斯坦福大学的这个项目

项目简介 Octopus-V2-2B是由斯坦福大学Nexa AI开发的一种先进的开源大型语言模型&#xff0c;具有20亿参数&#xff0c;专为Android API的功能调用定制。 与需要详细描述潜在函数参数的检索增强生成(RAG)方法不同Octopus-V2-2B采用了一种独特的功能性标记(functionaltokens)策…
阅读更多...
离散化实现低通滤波器（选用双线性变换）

离散化实现低通滤波器（选用双线性变换）

学习了离散化后整理了其中的核心步骤&#xff0c;此处不对原理进行深究&#xff0c;仅仅介绍如何对一个连续系统进行离散化 此处可以得到低通滤波器的截止频率为1000rad/s. 离散化的过程为将s 2/Ts * [(z - 1) / (z 1)] (选用双线性变换) 得到离散化序列为 Y(z) [w…
阅读更多...
02.安装MySQL

02.安装MySQL

安装MySQL 1.Windows使用压缩包安装MySQL8 下载安装包 地址&#xff1a;https://downloads.mysql.com/archives/community/ 解压安装包在没有中文和空格的目录下 省略 在解压目录创建my.ini文件并添加内容如下 不创建也是可以的&#xff0c;让它用默认的 配置环境变量 省…
阅读更多...
Kubernetes学习笔记13

Kubernetes学习笔记13

K8s集群核心概念&#xff1a;Service 我们在之前的学习过程中遇到一个问题&#xff0c;就是如果Pod被误删除&#xff0c;那么Controller重新拉起一个新的Pod时&#xff0c;我们发现PodIP地址是变化着的&#xff0c;我们访问必须更新IP地址。 这样对于大量的Pod运行应用来说&a…
阅读更多...
Linux双网卡默认路由优先级设置不正确，导致网络不通问题定位

Linux双网卡默认路由优先级设置不正确，导致网络不通问题定位

问题描述 RHEL9 双网卡环境&#xff0c;两个网卡配置如下&#xff1a;(eth0 走内网&#xff0c;eth1 走外网) eth0 192.168.10.20/24 网关: 192.168.10.254 eth1 10.206.216.92/24 网关: 10.206.216.254配置完成后&#xff0c;curl https://www.baidu.com访问百度失…
阅读更多...
鸿蒙HarmonyOS开发实战：【分布式音乐播放】

鸿蒙HarmonyOS开发实战：【分布式音乐播放】

介绍 本示例使用fileIo获取指定音频文件&#xff0c;并通过AudioPlayer完成了音乐的播放完成了基本的音乐播放、暂停、上一曲、下一曲功能&#xff1b;并使用DeviceManager完成了分布式设备列表的显示和分布式能力完成了音乐播放状态的跨设备分享。 本示例用到了与用户进行交…
阅读更多...
数据结构初阶：二叉树

数据结构初阶：二叉树

树概念及结构 树的概念 树是一种 非线性 的数据结构&#xff0c;它是由 n &#xff08; n>0 &#xff09;个有限结点组成一个具有层次关系的集合。 把它叫做树是因 为它看起来像一棵倒挂的树&#xff0c;也就是说它是根朝上&#xff0c;而叶朝下的 。 有一个特殊的结点&a…
阅读更多...
一体式I/O模块与RS485串口联动，实现工业网络无缝对接

一体式I/O模块与RS485串口联动，实现工业网络无缝对接

在现代工业自动化领域中&#xff0c;一体化I/O模块和RS485串口的联动应用已经成为实现工业设备高效、稳定通信的关键技术手段之一。这种联动机制能够有效地将各种现场设备的数据实时、准确地传输到上位机系统&#xff0c;从而实现工业网络的无缝对接。 一体化I/O模块&#xff…
阅读更多...
tailwindcss+vue3+vite+preline项目搭建

tailwindcss+vue3+vite+preline项目搭建

最近原子化样式比较火&#xff0c;用了一下确实还不错&#xff0c;也确实是用一些标准的样式能够使网页看起来比较统一&#xff0c;而且能够极大的减轻起名字的压力&#xff0c;有利有弊&#xff0c;就不一一细说了。 之前开发都是习惯于使用vitevue3来开发的&#xff0c;此次搭…
阅读更多...
ClickHouse--17--argMin() 和argMax()函数

ClickHouse--17--argMin() 和argMax()函数

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 argMin() 和argMax()函数业务场景使用案例1.准备表和数据&#xff1a;业务场景一&#xff1a;查看salary 最高和最小的user业务场景二&#xff1a;根据更新时间获取…
阅读更多...
C++11 数据结构0 什么是 “数据结构“？数据，数据对象，数据元素，数据项 概念。算法的基本概念 和 算法的度量，大O表示法，空间换时间的代码

C++11 数据结构0 什么是 “数据结构“？数据，数据对象，数据元素，数据项 概念。算法的基本概念 和 算法的度量，大O表示法，空间换时间的代码

数据&#xff1a; 是能输入计算机且能被计算机处理的各种符号的集合。数值型的数据&#xff1a;整数和实数。非数值型的数据&#xff1a;文字、图像、图形、声音等。 数据对象&#xff1a; 性质相同的 "数据元素" 的集合 例如一个 int arr[10], Teacher tea[3]; 数…
阅读更多...
C++设计模式：单例模式（十）

C++设计模式：单例模式（十）

1、单例设计模式 单例设计模式&#xff0c;使用的频率比较高&#xff0c;整个项目中某个特殊的类对象只能创建一个 并且该类只对外暴露一个public方法用来获得这个对象。 单例设计模式又分懒汉式和饿汉式&#xff0c;同时对于懒汉式在多线程并发的情况下存在线程安全问题 饿汉…
阅读更多...
每日OJ题_BFS解决FloodFill②_力扣200. 岛屿数量

每日OJ题_BFS解决FloodFill②_力扣200. 岛屿数量

目录 力扣200. 岛屿数量 解析代码 力扣200. 岛屿数量 200. 岛屿数量 难度 中等 给你一个由 1&#xff08;陆地&#xff09;和 0&#xff08;水&#xff09;组成的的二维网格&#xff0c;请你计算网格中岛屿的数量。 岛屿总是被水包围&#xff0c;并且每座岛屿只能由水平方…
阅读更多...
layui中对table表格内容鼠标移入显示 tips内容

layui中对table表格内容鼠标移入显示 tips内容

要在Layui中的表格中实现鼠标移入显示Tips&#xff0c;你可以使用Layui的事件监听和Tips组件。 有两种实现方式&#xff01; 第一种是&#xff0c;通过自定义鼠标事件显示 tips。在渲染 table 时&#xff0c;对 filed 进行重构&#xff0c;增加相应的选择器标识&#xff0c;一…
阅读更多...
OneForAll安装使用

OneForAll安装使用

OneForAll简介 OneForAll是一款功能强大的子域收集工具 原项目地址&#xff1a;GitHub - shmilylty/OneForAll: OneForAll是一款功能强大的子域收集工具 gitee项目地址&#xff1a;OneForAll: OneForAll是一款功能强大的子域收集工具 # 安装Python Windows系统安装python参…
阅读更多...
Excel文本内容抽取工具[Python]

Excel文本内容抽取工具[Python]

#创作灵感# 一堆Excel文件&#xff0c;每个打开看太累了。写个脚本直接显示里面的内容多好。最好这些内容可以直接复制到剪切板&#xff0c;方便以后编辑修改。只需要将文件拖动到全屏置顶的文本框内&#xff0c;就能弹出Excel里的内容。支持一次选取多个文件。 开干&#xff…
阅读更多...
react17+18 中 setState是同步还是异步更新

react17+18 中 setState是同步还是异步更新

在类组件中使用setState&#xff0c;在函数式组件中使用hooks的useState。 setstate目录 1. 类组件1.1 react 17版本1.2 react 18版本 2、函数式组件 1. 类组件 1.1 react 17版本 参考内容&#xff1a;第十一篇&#xff1a;setState 到底是同步的&#xff0c;还是异步的&…
阅读更多...
Unity类银河恶魔城学习记录12-8 p130 Skill Tree UI源代码

Unity类银河恶魔城学习记录12-8 p130 Skill Tree UI源代码

Alex教程每一P的教程原代码加上我自己的理解初步理解写的注释&#xff0c;可供学习Alex教程的人参考 此代码仅为较上一P有所改变的代码 【Unity教程】从0编程制作类银河恶魔城游戏_哔哩哔哩_bilibili UI.cs using UnityEngine;public class UI : MonoBehaviour {[SerializeFi…
阅读更多...
【精选】发布应用到应用商店的基本介

【精选】发布应用到应用商店的基本介

摘要 本文旨在介绍如何在各大应用商店发布应用&#xff0c;包括市场选择、准备材料、上架步骤以及常见被拒原因及解决方法。通过详细的步骤和经验分享&#xff0c;帮助开发者顺利将应用推向市场。 引言 随着移动应用市场的不断发展&#xff0c;越来越多的开发者希望将他们的…
阅读更多...
C++类和对象上

C++类和对象上

C和C语言本质区别 C语言是面向过程的&#xff0c;面向过程的&#xff0c;分析出求解问题的步骤&#xff0c;然后逐步通过函数调用来逐步解决问题。 C在分析问题是在面对对象的基础上来实现的&#xff0c;即将一件事情拆分为不同的对象&#xff0c;靠的是对象之间的交互来完成的…
阅读更多...
最新文章

Copyright @ 2022~2023