STM32存储左右互搏 USB接口FATS文件读写U盘

news2024/10/5 19:13:53

STM32存储左右互搏 USB接口FATS文件读写U盘

STM32的USB接口可以例化为Host主机从而对U盘进行操作。SD卡/MicroSD/TF卡也可以通过读卡器转换成U盘使用。这里介绍STM32CUBEIDE开发平台HAL库实现U盘FATS文件访问的例程。

USB接口介绍

常见的USB接口电路部分相似而有不同的连接器应用，连接器有USB-A, USB-MINI, USB-MICRO, USB-TYPEC等。除了USB-A可以直接插入U盘,其它连接器可以通过转接板和转接线和U盘连接。如果用USB-TYPEC公头的U盘，则可以直接插入USB-TYPEC母座的主机。

常见USB-TYPEC接口电路如下：

在这里插入图片描述
去繁化简，主要是5V电源输入，接地，差分信号+ （DP）， 差分信号- （DN）4个有效连接。对于STM32, DP连接到了PA12管脚， DN连接到了PA11管脚.

例程采用STM32F401CCU6芯片(兼容STM32F401RCT6, 仅封装不同)对U盘进行识别和读写操作。工程平台为STM32CUBEIDE。

STM32工程配置

首先建立基本工程并设置时钟，USB应用需要采用外部晶体时钟:
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
配置UART1作为通讯控制口：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
配置USB接口：
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
配置U盘接口：
在这里插入图片描述
需要单独配置一个不用的GPIO作为输出，并在U盘接口配置参数里选择，这个管脚实际是对应对U盘供电的开关控制，很多板上没有设计出来。
在这里插入图片描述
在这里插入图片描述
再增加一个LED指示灯的控制管脚，这里是PC13，用于U盘操作过程中的指示。

在这里插入图片描述
然后配置FATS文件操作参数：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
保存并生成初始工程代码:
在这里插入图片描述

STM32工程代码

UART串口printf打印输出实现参考：STM32 UART串口printf函数应用及浮点打印代码空间节省 (HAL)

功能代码里实现对USB进行轮询检测，当检测到U盘插入后进行闪灯，当U盘准好操作时保持亮灯。
通过串口发送单字节指令，进行控制操作：
0x01: 装载USB FATS系统
0x02: 创建/打开文件并从头位置写入数据
0x02: 打开文件并从头位置读入数据
0x02: 创建/打开文件并从特定位置写入数据
0x02: 打开文件并从特定位置读入数据

完整的main.c文件如下：

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
//Written by Pegasus Yu in 2023
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "fatfs.h"
#include "usb_host.h"

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

#include "usart.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
__IO float usDelayBase;
void PY_usDelayTest(void)
{
  __IO uint32_t firstms, secondms;
  __IO uint32_t counter = 0;

  firstms = HAL_GetTick()+1;
  secondms = firstms+1;

  while(uwTick!=firstms) ;

  while(uwTick!=secondms) counter++;

  usDelayBase = ((float)counter)/1000;
}

void PY_Delay_us_t(uint32_t Delay)
{
  __IO uint32_t delayReg;
  __IO uint32_t usNum = (uint32_t)(Delay*usDelayBase);

  delayReg = 0;
  while(delayReg!=usNum) delayReg++;
}

void PY_usDelayOptimize(void)
{
  __IO uint32_t firstms, secondms;
  __IO float coe = 1.0;

  firstms = HAL_GetTick();
  PY_Delay_us_t(1000000) ;
  secondms = HAL_GetTick();

  coe = ((float)1000)/(secondms-firstms);
  usDelayBase = coe*usDelayBase;
}


void PY_Delay_us(uint32_t Delay)
{
  __IO uint32_t delayReg;

  __IO uint32_t msNum = Delay/1000;
  __IO uint32_t usNum = (uint32_t)((Delay%1000)*usDelayBase);

  if(msNum>0) HAL_Delay(msNum);

  delayReg = 0;
  while(delayReg!=usNum) delayReg++;
}
/* 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 ---------------------------------------------------------*/
UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */
extern ApplicationTypeDef Appli_state; //UDISK available status

uint8_t uart1_rxd[256]; //Uart1 rx buffer
uint8_t uart1_txd[256]; //Uart1 tax buffer
uint8_t cmd; //Uart1 command indication
uint8_t ustatus = 0; //UDISK ready to operation indication (0: not ready; 1: ready)
uint8_t disk_mount_status = 0; //Disk fats mount status indication (0: unmount; 1: mount)
uint8_t FATS_Buff[_MAX_SS]; //Buffer for f_mkfs() operation

FIL file; //File object for fats operation
UINT bytesread; //Byte number of read operation
UINT byteswritten;//Byte number of write operation
uint8_t rBuffer[20];      //Buffer for read
uint8_t WBuffer[20] ={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}; //Buffer for write
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
void MX_USB_HOST_Process(void);

/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
#define LED_OFF HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET)
#define LED_ON HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET)
#define LED_FLASH HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13)
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */
	FRESULT retUSB; //Operation return result status
	disk_mount_status = 0;

	uint32_t USB_Read_Size; //Read operation byte number
	const TCHAR* filepath = "0:test.txt"; //File partition number and name
  /* 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_FATFS_Init();
  MX_USB_HOST_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
  PY_usDelayTest();
  PY_usDelayOptimize();

  HAL_UART_Receive_IT(&huart1, uart1_rxd, 1);
  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */

   if(Appli_state==APPLICATION_START)
   {
	   LED_FLASH;
	   PY_Delay_us_t(500000);
	   ustatus=0;

   }
   else if(Appli_state==APPLICATION_READY) //Status shift time from APPLICATION_START to APPLICATION_READY is about 90 second.
   {
	   LED_ON;
	   ustatus=1;
   }
   else
   {
	   LED_OFF;
	   ustatus = 0;
   }


    if(cmd>0)
    {
    	if(ustatus!=1)
    	{
    		cmd = 0;
    		printf("\r\nUSB disk not ready!\r\n");
    	}
    	else
    	{

    		  if(cmd==0x01) //Mount USB
    		  {
    			  cmd = 0;


    	       if(disk_mount_status==1) printf("\r\nUSB mounted already\r\n");
    	       else
    	       {

    	     	  retUSB = f_mount(&USBHFatFS,(TCHAR const*)USBHPath,1); //SD mount

    	     	  if(retUSB==FR_NO_FILESYSTEM)
    	     	  {
    	     		printf("\r\nFile system doesn't exist. Now to format......\r\n");
    	   			retUSB = f_mkfs((TCHAR const*)USBHPath, FM_FAT, 1024, FATS_Buff, sizeof(FATS_Buff)); //USB format
    	   			if(retUSB != FR_OK )
    	   			{
    	   				printf("\r\nFormat error: %d\r\n",retUSB);
    	   			}
    	   			else
    	   			{
    	   				printf("\r\nFormat OK\r\n");

    	   			}
    	     	   }
    	   		   else if(retUSB==FR_OK)
    	   		   {
    	   			    disk_mount_status = 1;
    	   			    printf("\r\nUSB mount successful\r\n");

    	   			}
    	   			else
    	   			{
    	   				printf("\r\nUSB mount error: %d\r\n",retUSB);
    	   			}
    	     	  }
    	     }
    		    else if(cmd==2) //File creation and write
    		    {
    			  cmd = 0;

    			  if(disk_mount_status==0) printf("\r\nUSB not mounted: %d\r\n",retUSB);
    			  else
    			  {
    					retUSB = f_open( &file, filepath, FA_CREATE_ALWAYS | FA_WRITE );  //Open or create file
    					if(retUSB == FR_OK)
    					{
    						printf("\r\nFile open or creation successful\r\n");

    						retUSB = f_write( &file, (const void *)WBuffer, sizeof(WBuffer), &byteswritten); //Write data

    						if(retUSB == FR_OK)
    						{
    							printf("\r\nFile write successful\r\n");

    						}
    						else
    						{
    							printf("\r\nFile write error: %d\r\n",retUSB);
    						}

    						f_close(&file);   //Close file
    					}
    					else
    					{
    						printf("\r\nFile open or creation error %d\r\n",retUSB);
    					}
    			   }

    		    }
    		    else if(cmd==3) //File read
    		    {
    			  cmd = 0;

    			  if(disk_mount_status==0) printf("\r\nUSB not mounted: %d\r\n",retUSB);
    			  else
    			  {
    					retUSB = f_open( &file, filepath, FA_OPEN_EXISTING | FA_READ); //Open file
    					if(retUSB == FR_OK)
    					{
    						printf("\r\nFile open successful\r\n");

    						retUSB = f_read( &file, (void *)rBuffer, sizeof(rBuffer), &bytesread); //Read data

    						if(retUSB == FR_OK)
    						{
    							printf("\r\nFile read successful\r\n");
    							PY_Delay_us_t(200000);

    							USB_Read_Size = sizeof(rBuffer);
    							for(uint16_t i = 0;i < USB_Read_Size;i++)
    							{
    								printf("%d ", rBuffer[i]);
    							}
    							printf("\r\n");

    						}
    						else
    						{
    							printf("\r\nFile read error: %d\r\n", retUSB);
    						}
    						f_close(&file); //Close file
    					}
    					else
    					{
    						printf("\r\nFile open error: %d\r\n", retUSB);
    					}
    			  }

    		    }
    		    else if(cmd==4) //File locating write
    		    {
    			  cmd = 0;

    			  if(disk_mount_status==0) printf("\r\nUSB not mounted: %d\r\n",retUSB);
    			  else
    			  {
    					retUSB = f_open( &file, filepath, FA_CREATE_ALWAYS | FA_WRITE);  //Open or create file
    					if(retUSB == FR_OK)
    					{
    						printf("\r\nFile open or creation successful\r\n");

    						retUSB=f_lseek( &file, f_tell(&file) + sizeof(WBuffer) ); //move file operation pointer, f_tell(&file) gets file head locating

    						if(retUSB == FR_OK)
    						{

    							retUSB = f_write( &file, (const void *)WBuffer, sizeof(WBuffer), &byteswritten);
    							if(retUSB == FR_OK)
    							{
    								printf("\r\nFile locating write successful\r\n");
    							}
    							else
    							{
    								printf("\r\nFile locating write error: %d\r\n", retUSB);
    							}

    						}
    						else
    						{
    							printf("\r\nFile pointer error: %d\r\n",retUSB);
    						}

    						f_close(&file);   //Close file
    					}
    					else
    					{
    						printf("\r\nFile open or creation error %d\r\n",retUSB);
    					}
    			  }
    		    }
    		    else if(cmd==5) //File locating read
    		    {
    			  cmd = 0;

    			  if(disk_mount_status==0) printf("\r\nUSB not mounted: %d\r\n",retUSB);
    			  else
    			  {
    					retUSB = f_open(&file, filepath, FA_OPEN_EXISTING | FA_READ); //Open file
    					if(retUSB == FR_OK)
    					{
    						printf("\r\nFile open successful\r\n");

    						retUSB =  f_lseek(&file,f_tell(&file)+ sizeof(WBuffer)/2); //move file operation pointer, f_tell(&file) gets file head locating

    						if(retUSB == FR_OK)
    						{
    							retUSB = f_read( &file, (void *)rBuffer, sizeof(rBuffer), &bytesread);
    							if(retUSB == FR_OK)
    							{
    								printf("\r\nFile locating read successful\r\n");
    								PY_Delay_us_t(200000);

    								USB_Read_Size = sizeof(rBuffer);
    								for(uint16_t i = 0;i < USB_Read_Size;i++)
    								{
    									printf("%d ",rBuffer[i]);
    								}
    								printf("\r\n");
    							}
    							else
    							{
    								printf("\r\nFile locating read error: %d\r\n",retUSB);
    							}
    						}
    						else
    						{
    							printf("\r\nFile pointer error: %d\r\n",retUSB);
    						}
    						f_close(&file);
    					}
    					else
    					{
    						printf("\r\nFile open error: %d\r\n",retUSB);
    					}
    			  }
    		    }
    		    else;


    	}

    }

  }
  /* 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_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 25;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  RCC_OscInitStruct.PLL.PLLQ = 7;
  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_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

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

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);

  /*Configure GPIO pin : PC13 */
  GPIO_InitStruct.Pin = GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pin : PA8 */
  GPIO_InitStruct.Pin = GPIO_PIN_8;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  if(huart==&huart1)
  {
	  cmd = uart1_rxd[0];
	  HAL_UART_Receive_IT(&huart1, uart1_rxd, 1);
  }
}
/* USER CODE END 4 */

/**
  * @brief  Period elapsed callback in non blocking mode
  * @note   This function is called  when TIM1 interrupt took place, inside
  * HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment
  * a global variable "uwTick" used as application time base.
  * @param  htim : TIM handle
  * @retval None
  */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  /* USER CODE BEGIN Callback 0 */

  /* USER CODE END Callback 0 */
  if (htim->Instance == TIM1) {
    HAL_IncTick();
  }
  /* USER CODE BEGIN Callback 1 */

  /* USER CODE END Callback 1 */
}

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

注意其中的f_mkfs格式化U盘库函数在不同的库版本参数数量不一样，上面范例是参数较多的版本，根据实际库函数调整即可。

STM32例程测试

串口指令0x01测试效果如下：
在这里插入图片描述

串口指令0x02测试效果如下：
在这里插入图片描述

串口指令0x03测试效果如下：
在这里插入图片描述

串口指令0x04测试效果如下：
在这里插入图片描述

串口指令0x05测试效果如下：
在这里插入图片描述

注意事项

STM32从识别U盘连接到可操作状态准备好时间比较长，实测约90秒
STM32做U盘容量识别时间也比较长，实测4GB U盘容量识别时间达到3~4分钟。

STM32例程下载

STM32F401CCU6 USB接口FATS文件读写U盘例程下载

–End–

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

数据分离和混淆矩阵的学习

数据分离和混淆矩阵的学习

1.明确意义 通过训练集建立模型的意义是对新的数据进行准确的预测&#xff08;测试集的准度高才代表good fit&#xff09;&#xff1b; 2.评估流程 3.单单利用准确率accuracy进行模型评估的局限性 模型一&#xff1a;一共1000个数据&#xff08;分别为900个1和100个0&#x…
阅读更多...
网站服务器备案及域名购买配置教程

网站服务器备案及域名购买配置教程

一、阿里云服务备案准备工作 1.什么是备案？ 备案是指向相关部门提交网站信息，以便监管和管理互联网信息服务，未经备案的网站可能面临罚款甚至被关闭的风险。备案主要看您的网站或App等互联网信息服务解析到的服务器是否在中国内地（大陆），如果服务器在中国内地（大陆），…
阅读更多...
Postman基础功能-Collection集合和批量运行

Postman基础功能-Collection集合和批量运行

一、Collection&#xff08;集合&#xff09;介绍 当我们对一个或多个系统中的很多接口用例进行维护时&#xff0c;首先想到的就是对接口用例进行分类管理&#xff0c;同时还希望对这批接口用例做回归测试。 在 Postman 中也提供了这样一个功能&#xff0c;就是 Collec…
阅读更多...
Aim Web API 远程代码执行

Aim Web API 远程代码执行

摘要 漏洞类型&#xff1a;远程代码执行&#xff08;RCE&#xff09;产品&#xff1a;目标版本&#xff1a;> 3.0.0&#xff08;afaik&#xff09;受影响的端点&#xff1a; /api/runs/search/run/严重性&#xff1a;临界 描述 在aim项目中发现了一个关键的远程代码执行漏…
阅读更多...
设计模式 六大原则之里氏替换原则

设计模式 六大原则之里氏替换原则

文章目录 概念替换逻辑行为不变 拆解小结 概念 子类对象能够替换程序中父类对象出现的任何地方&#xff0c;并且保证原来程序的逻辑行为不变及正确性不被破坏。 替换 替换的前提是面向对象语言所支持的多态特性&#xff0c;同一个行为具有多个不同表现形式或形态的能力。 逻…
阅读更多...
js基础-数组-事件对象-日期-本地存储

js基础-数组-事件对象-日期-本地存储

一、大纲 一、获取元素位置 在JavaScript中&#xff0c;获取一个元素在页面上的位置可以通过多种方法实现。以下是一些常见的方法&#xff1a; getBoundingClientRect() getBoundingClientRect() 方法返回元素的大小及其相对于视口的位置。它提供了元素的left、top、right和bo…
阅读更多...
Tkinter组件：Text-显示和处理多行文本

Tkinter组件：Text-显示和处理多行文本

Tkinter组件&#xff1a;Text Text&#xff08;文本&#xff09;组件用于显示和处理多行文本。在 Tkinter 的所有组件中&#xff0c;Text 组件显得异常强大和灵活&#xff0c;适用于多种任务。虽然该组件的主要目的是显示多行文本&#xff0c;但它常常也被用于作为简单的文本编…
阅读更多...
【单片机调试】mcu调试bug记录

【单片机调试】mcu调试bug记录

【单片机调试】mcu调试bug记录 2023.5-2023.11待输入 2023.12-2023.22024.3-至今1.spi通信问题 2023.5-2023.11 待输入 2023.12-2023.2 辞职阶段&#xff1a;【STM32调试】寄存器调试不良问题记录持续版 2024.3-至今 1.spi通信问题 现象说明&#xff1a; mcu与afe芯片为spi通…
阅读更多...
为什么使用AI 在游戏中不犯法

为什么使用AI 在游戏中不犯法

使用AI在游戏中本身并不违法&#xff0c;甚至在很多情况下&#xff0c;游戏公司自己也会在游戏中集成AI来提高游戏体验&#xff0c;例如通过AI驱动的非玩家角色&#xff08;NPC&#xff09;来增加游戏的互动性和挑战性。然而&#xff0c;使用AI是否违法取决于AI的使用方式和目的…
阅读更多...
设计一个游戏的基本博弈框架

设计一个游戏的基本博弈框架

设计一个游戏的基本博弈框架&#xff0c;玩家通过操作改变某个数值&#xff0c;这个数值的变动会引发一系列实时变化&#xff0c;并且当这些数值累计到特定阈值时&#xff0c;会导致游戏中出现其他变化&#xff0c;可以分为以下几个步骤&#xff1a; 1. 确定游戏类型和主题 首…
阅读更多...
邮件地址采集软件有哪些-邮箱地址采集软件

邮件地址采集软件有哪些-邮箱地址采集软件

邮件地址采集软件是帮助用户收集、管理和使用邮件地址的工具&#xff0c;它们在商业营销、市场调研、网络爬虫等领域有着广泛的应用。以下是一些常见的邮件地址采集软件&#xff1a; 易邮件地址搜索大师&#xff1a;易邮件地址搜索大师是一款搜索邮件地址和手机号码的软件&…
阅读更多...
一篇文章拿下Redis 通用命令

一篇文章拿下Redis 通用命令

文章目录 Redis数据结构介绍Redis 通用命令命令演示KEYSDELEXISTSEXPIRE RedisTemplate 中的通用命令 本篇文章介绍 Redis 的通用命令, 通用命令在 Redis 的所有数据类型下都使用, 学好通用命令可以让我们更好的使用 Redis. Redis数据结构介绍 Redis 是一个key-value的数据库&…
阅读更多...
如何进行免杀

如何进行免杀

0x03 免杀思路总结 环境准备&#xff1a; 火绒&#xff08;静态&#xff09;、360、windowsdef&#xff08;动态&#xff09; 免杀的最基本思路就是去除其特征&#xff0c;这个特征有可能是特征码&#xff0c;也有可能是行为特征&#xff0c;只要在不修改其 原有功能的情况下…
阅读更多...
基于C#开发web网页管理系统模板流程-登录界面

基于C#开发web网页管理系统模板流程-登录界面

前言&#xff0c;首先介绍一下本项目将要实现的功能 &#xff08;一&#xff09;登录界面 实现一个不算特别美观的登录窗口&#xff0c;当然这一步跟开发者本身的设计美学相关&#xff0c;像蒟蒻博主就没啥艺术细胞&#xff0c;勉强能用能看就行…… &#xff08;二&#xff09…
阅读更多...
极验3滑块逆向分析

极验3滑块逆向分析

1、底图还原 下 断点&#xff0c;可以分析底图还原逻辑 2、跟W值 var Str_Unicodefunction(str){var unid\\u00;for(let i0,lenstr.length;i<len;i){if(i<len-1){unidstr.charCodeAt(i).toString(16)\\u00;}else if(ilen-1){unidstr.charCodeAt(i).toString(16);}}re…
阅读更多...
【数据结构】数组循环队列的实现

【数据结构】数组循环队列的实现

队列&#xff08;Queue&#xff09;是一种特殊的线性数据结构&#xff0c;它遵循FIFO&#xff08;First In First Out&#xff0c;先入先出&#xff09;的原则。队列只允许在表的前端&#xff08;front&#xff09;进行删除操作&#xff0c;而在表的后端&#xff08;rear&#…
阅读更多...
【408精华知识】提高外部排序速度的三种方式

【408精华知识】提高外部排序速度的三种方式

文章目录 一、败者树二、置换-选择排序三、最佳归并树 一、败者树 还没写完… 二、置换-选择排序 三、最佳归并树 写在后面 这个专栏主要是我在学习408真题的过程中总结的一些笔记&#xff0c;因为我学的也很一般&#xff0c;如果有错误和不足之处&#xff0c;还望大家在评…
阅读更多...
HTML的使用（上）

HTML的使用（上）

文章目录 前言一、HTML是什么&#xff1f;二、使用内容 &#xff08;1&#xff09;换行标记<br>&#xff08;2&#xff09;加粗标记<b> </b>&#xff08;3&#xff09;段落标记<p> </p>&#xff08;4&#xff09;标题标记<h1>~<h6> …
阅读更多...
Autosar架构

Autosar架构

蓝框那种叫component&#xff0c;绿框的叫function cluster。 接口 有三种接口&#xff0c;RTE跟SWC之间链接的叫Autosar Interface&#xff0c;RTE跟BSW的Components链接是Standardized Interface&#xff0c;RTE跟BSW的services链接的是Standardized Autosar Interface。 St…
阅读更多...
P6397 [COI2008] GLASNICI

P6397 [COI2008] GLASNICI

题目描述 一条直线上有 &#x1d45b; 个信使&#xff0c;将他们按照从左至右的顺序以 1 至 &#x1d45b; 编号。换句话说&#xff0c;设 &#x1d456; 号信使的的坐标为 &#x1d451;&#x1d456;​&#xff0c;则对于 1≤&#x1d456;<&#x1d45b;&#xff0c; &am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023