STM32CUBEIDE FreeRTOS操作教程（八）：queues多队列

news2024/11/26 9:59:31

STM32CUBEIDE FreeRTOS操作教程（八）：queues多队列

STM32CUBE开发环境集成了STM32 HAL库进行FreeRTOS配置和开发的组件，不需要用户自己进行FreeRTOS的移植。这里介绍最简化的用户操作类应用教程。以STM32F401RCT6开发板为例，只用到USB，USART1极少的接口，体现FreeRTOS的各种操作过程。
在这里插入图片描述
操作教程（八）配置FreeRTOS及相关环境，实现LED闪灯功能及基于queue多队列的USB虚拟串口收发环回。从电脑端连接USB虚拟串口后，发送出去的串口数据，会被一个队列保存，而长度信息会保存在另一个队列，在任务中发现长度信息的队列非空，以及保存数据的队列非空，则将数据通过USB虚拟串口返回电脑端。

FreeRTOS的教程较多，推荐参考正点原子所出的《STM32F407 FreeRTOS开发手册》了解相关知识。
在这里插入图片描述
在这里插入图片描述

STM32CUBEIDE工程配置

选择TIM1(也可以是其它TIM)作为FreeRTOS操作系统占用的时钟源：
在这里插入图片描述

在这里插入图片描述

配置时钟树包括USB的48MHz时钟：
在这里插入图片描述
配置PC13为低电平点灯的管脚：
在这里插入图片描述
配置USB串口:
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
配置UART1串口（但本例中不用到UART1):
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

FreeRTOS配置

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
保存并生成基础工程代码：
在这里插入图片描述
在生成代码的这个部分可以看到FreeRTOS代码部分：
在这里插入图片描述

任务实现

基于前述的配置，main.c代码里会加载Free-RTOS的配置，并启动几个任务的调度，当然，此时的任务都是什么也不干。实现LED闪灯，就在LED闪灯任务里加入代码即可：

void StartTask_TASK_LED_FLASH(void *argument)
{
  /* USER CODE BEGIN StartTask_TASK_LED_FLASH */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1000);
    HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
  }
  /* USER CODE END StartTask_TASK_LED_FLASH */
}

也就实现了LED闪灯功能，其中osDelay(1000);实现1秒时间的操作系统调度延时，也就是1秒执行一次LED灯的亮灭。osDelay(1）；是最小的调度延时，为1毫秒。要实现更小的延时，则可以用微秒延时函数实现，参考《STM32 HAL us delay（微秒延时）的指令延时实现方式及优化》。

在USB的接收中断里，向一个队列里入数据，向另一个队列里写入数据长度，在任务里检测到数据长度队列非空，则将数据队列里的数据向USB虚拟串口输出。

USB接收部分的代码：
在这里插入图片描述

static int8_t CDC_Receive_FS(uint8_t* Buf, uint32_t *Len)
{
  /* USER CODE BEGIN 6 */
	extern osMessageQueueId_t USB_VCOM_Queue01_IndexHandle;
	extern osMessageQueueId_t USB_VCOM_Queue01Handle;
	extern BaseType_t USB_VCOM_pxHigherPriorityTaskWaken;


    memcpy(uvbuff, Buf, *Len);

	xQueueOverwriteFromISR(USB_VCOM_Queue01Handle, uvbuff, &USB_VCOM_pxHigherPriorityTaskWaken);
	xQueueOverwriteFromISR(USB_VCOM_Queue01_IndexHandle, Len, &USB_VCOM_pxHigherPriorityTaskWaken);


  USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &Buf[0]);
  USBD_CDC_ReceivePacket(&hUsbDeviceFS);
  return (USBD_OK);
  /* USER CODE END 6 */
}

main.c文件里任务处理：

void StartTask_TASK_USB_VCOM(void *argument)
{
  /* USER CODE BEGIN StartTask_TASK_USB_VCOM */
  BaseType_t err_stu = pdFALSE;
  uint8_t USB_VCOM_B[1024];
  uint32_t USB_VCOM_I = 0;
  /* Infinite loop */
  for(;;)
  {
    osDelay(10);

    if(xQueueReceive(USB_VCOM_Queue01_IndexHandle, &USB_VCOM_I, &USB_VCOM_pxHigherPriorityTaskWaken)!=err_stu)
    {
    	if(xQueueReceive(USB_VCOM_Queue01Handle, USB_VCOM_B, &USB_VCOM_pxHigherPriorityTaskWaken)!=err_stu)
    	{
    		usbprintarray(USB_VCOM_B, USB_VCOM_I);
    	}
    }

  }
  /* USER CODE END StartTask_TASK_USB_VCOM */
}

完整的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.
  *
  ******************************************************************************
  */
//Example 8: LED flash + USB VCOM loop back with 2-Queue
//Written by Pegasus Yu
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "cmsis_os.h"
#include "usb_device.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "queue.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
__IO float usDelayBase = 7.63238716; //For STM32F401RCT6 working in 84MHz main clock

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++;
}
/* 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;
DMA_HandleTypeDef hdma_usart1_rx;

/* Definitions for defaultTask */
osThreadId_t defaultTaskHandle;
const osThreadAttr_t defaultTask_attributes = {
  .name = "defaultTask",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for TASK_LED_FLASH */
osThreadId_t TASK_LED_FLASHHandle;
const osThreadAttr_t TASK_LED_FLASH_attributes = {
  .name = "TASK_LED_FLASH",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for TASK_UART1 */
osThreadId_t TASK_UART1Handle;
const osThreadAttr_t TASK_UART1_attributes = {
  .name = "TASK_UART1",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for TASK_USB_VCOM */
osThreadId_t TASK_USB_VCOMHandle;
const osThreadAttr_t TASK_USB_VCOM_attributes = {
  .name = "TASK_USB_VCOM",
  .stack_size = 2048 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for USB_VCOM_Queue01 */
osMessageQueueId_t USB_VCOM_Queue01Handle;
const osMessageQueueAttr_t USB_VCOM_Queue01_attributes = {
  .name = "USB_VCOM_Queue01"
};
/* Definitions for USB_VCOM_Queue01_Index */
osMessageQueueId_t USB_VCOM_Queue01_IndexHandle;
const osMessageQueueAttr_t USB_VCOM_Queue01_Index_attributes = {
  .name = "USB_VCOM_Queue01_Index"
};
/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_USART1_UART_Init(void);
void StartDefaultTask(void *argument);
void StartTask_TASK_LED_FLASH(void *argument);
void StartTask_TASK_UART1(void *argument);
void StartTask_TASK_USB_VCOM(void *argument);

/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uint8_t CDC_Transmit_FS(uint8_t* Buf, uint16_t Len);
void usbprintstring(char * data)
{
	if(CDC_Transmit_FS((uint8_t *)data, strlen(data))==USBD_BUSY)
	{
		PY_Delay_us_t(1000000);
	    CDC_Transmit_FS((uint8_t *)data, strlen(data));
	}
}

void usbprintarray(uint8_t * data, uint16_t len)
{
	if(CDC_Transmit_FS(data, len)==USBD_BUSY)
	{
		PY_Delay_us_t(1000000);
		CDC_Transmit_FS(data, len);
	}
}

BaseType_t USB_VCOM_pxHigherPriorityTaskWaken = 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_DMA_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Init scheduler */
  osKernelInitialize();

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* Create the queue(s) */
  /* creation of USB_VCOM_Queue01 */
  USB_VCOM_Queue01Handle = osMessageQueueNew (1, 1024, &USB_VCOM_Queue01_attributes);

  /* creation of USB_VCOM_Queue01_Index */
  USB_VCOM_Queue01_IndexHandle = osMessageQueueNew (1, sizeof(uint32_t), &USB_VCOM_Queue01_Index_attributes);

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* creation of defaultTask */
  defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);

  /* creation of TASK_LED_FLASH */
  TASK_LED_FLASHHandle = osThreadNew(StartTask_TASK_LED_FLASH, NULL, &TASK_LED_FLASH_attributes);

  /* creation of TASK_UART1 */
  TASK_UART1Handle = osThreadNew(StartTask_TASK_UART1, NULL, &TASK_UART1_attributes);

  /* creation of TASK_USB_VCOM */
  TASK_USB_VCOMHandle = osThreadNew(StartTask_TASK_USB_VCOM, NULL, &TASK_USB_VCOM_attributes);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  /* USER CODE END RTOS_THREADS */

  /* USER CODE BEGIN RTOS_EVENTS */
  /* add events, ... */
  /* USER CODE END RTOS_EVENTS */

  /* Start scheduler */
  osKernelStart();

  /* We should never get here as control is now taken by the scheduler */
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* 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_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 */

}

/**
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void)
{

  /* DMA controller clock enable */
  __HAL_RCC_DMA2_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA2_Stream2_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);

}

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

  /* 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(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);

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

/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/* USER CODE BEGIN Header_StartDefaultTask */
/**
  * @brief  Function implementing the defaultTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void *argument)
{
  /* init code for USB_DEVICE */
  MX_USB_DEVICE_Init();
  /* USER CODE BEGIN 5 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END 5 */
}

/* USER CODE BEGIN Header_StartTask_TASK_LED_FLASH */
/**
* @brief Function implementing the TASK_LED_FLASH thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask_TASK_LED_FLASH */
void StartTask_TASK_LED_FLASH(void *argument)
{
  /* USER CODE BEGIN StartTask_TASK_LED_FLASH */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1000);
    HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
  }
  /* USER CODE END StartTask_TASK_LED_FLASH */
}

/* USER CODE BEGIN Header_StartTask_TASK_UART1 */
/**
* @brief Function implementing the TASK_UART1 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask_TASK_UART1 */
void StartTask_TASK_UART1(void *argument)
{
  /* USER CODE BEGIN StartTask_TASK_UART1 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartTask_TASK_UART1 */
}

/* USER CODE BEGIN Header_StartTask_TASK_USB_VCOM */
/**
* @brief Function implementing the TASK_USB_VCOM thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask_TASK_USB_VCOM */
void StartTask_TASK_USB_VCOM(void *argument)
{
  /* USER CODE BEGIN StartTask_TASK_USB_VCOM */
  BaseType_t err_stu = pdFALSE;
  uint8_t USB_VCOM_B[1024];
  uint32_t USB_VCOM_I = 0;
  /* Infinite loop */
  for(;;)
  {
    osDelay(10);

    if(xQueueReceive(USB_VCOM_Queue01_IndexHandle, &USB_VCOM_I, &USB_VCOM_pxHigherPriorityTaskWaken)!=err_stu)
    {
    	if(xQueueReceive(USB_VCOM_Queue01Handle, USB_VCOM_B, &USB_VCOM_pxHigherPriorityTaskWaken)!=err_stu)
    	{
    		usbprintarray(USB_VCOM_B, USB_VCOM_I);
    	}
    }

  }
  /* USER CODE END StartTask_TASK_USB_VCOM */
}

/**
  * @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 */

例程下载

STM32 STM32CUBEIDE FreeRTOS操作教程（八）：queues多队列 例程

例程测试

例程测试效果如下：

在这里插入图片描述

–End–

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

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

相关文章

防火墙|WAF|漏洞|网络安全

防火墙|WAF|漏洞|网络安全

防火墙|WAF|漏洞|网络安全 防火墙 根据内容分析数据包： 1、源IP和目的IP地址 2、有效负载中的内容。 3、数据包协议（例如，连接是否使用 TCP/IP 协议）。 4、应用协议（HTTP、Telnet、FTP、DNS、SSH 等）。 5…
阅读更多...
【04】【Maven项目热部署】将Maven项目热部署到远程tomcat服务器上

【04】【Maven项目热部署】将Maven项目热部署到远程tomcat服务器上

1.虽然现在Maven中央仓库中支持的tomcat插件只支持到tomcat7这个版本，但是可以利用这个插件对Web项目进行热部署，热部署到远程服务器的tomcat服务器上，远程服务器上的tomcat版本可以是更高的版本，比如说tomcat8、9、10或更高的版本…
阅读更多...
大数据新视界 -- 大数据大厂之 Impala 性能优化：融合机器学习的未来之路（上 （2-1））（11/30）

大数据新视界 -- 大数据大厂之 Impala 性能优化：融合机器学习的未来之路（上 （2-1））（11/30）

💖💖💖亲爱的朋友们，热烈欢迎你们来到 青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而 我的…
阅读更多...
解决：使用EasyExcel导入Excel模板时出现数据导入不进去的问题

解决：使用EasyExcel导入Excel模板时出现数据导入不进去的问题

解决：使用EasyExcel导入Excel模板时出现数据导入不进去的问题 在Java中，当我们用EasyExcel导入Excel时，可能会出现数据导入不进去的问题。例如： 这种异常等。 问题原因1：这个1代表从第几行开始，你的exce…
阅读更多...
在vscode中开发运行uni-app项目

在vscode中开发运行uni-app项目

确保电脑已经安装配置好了node、vue等相关环境依赖 进行项目的创建 vue create -p dcloudio/uni-preset-vue 项目名 vue create -p dcloudio/uni-preset-vue uni-app 选择模版 这里选择【默认模版】 项目创建成功后在vscode中打开 第一次打开项目 pages.json 文件会报错&a…
阅读更多...
如何修改WordPress经典编辑器的默认高度？

如何修改WordPress经典编辑器的默认高度？

boke112百科有一个使用WordPress搭建的小网站，文章内容就是几个字不到一行，但是每次使用经典编辑器编辑文章时，都觉得编辑器默认高度太高了，影响了我添加文章摘要和其他属性，有没有办法修改WordPress经典编辑器的默认高…
阅读更多...
汽车广告常见特效处理有哪些？

汽车广告常见特效处理有哪些？

​汽车广告作为展示汽车性能和外观的重要媒介，常常需要借助特效来增强视觉效果，吸引观众的注意力。以下是一篇关于汽车广告中常见特效处理的文章。 在竞争激烈的汽车市场中，广告不仅是推广产品的工具，更是艺术和科技的结合。特效技…
阅读更多...
从0开始学习机器学习--Day19--学习曲线

从0开始学习机器学习--Day19--学习曲线

一般来说，如果一个算法的表现不理想，那么多半是因为出现了欠拟合或过拟合问题，这种时候我们要做的就是搞清楚出现的是偏差问题还是方差问题，亦或是二者皆有，这有助于我们精准定位问题所在。 之前，我们发现…
阅读更多...
HarmonyOS NEXT 应用开发实战（九、知乎日报项目详情页实现详细介绍）

HarmonyOS NEXT 应用开发实战（九、知乎日报项目详情页实现详细介绍）

在本篇博文中，我们将探讨如何使用 HarmonyOS Next 框架开发一个知乎日报的详情页，逐步介绍所用到的组件及代码实现。知乎日报是个小巧完整的小项目，这是一个循序渐进的过程，适合初学者和有一定开发经验的工程师参考。 1. 项目背景…
阅读更多...
LLM训练”中的“分布式训练并行技术；分布式训练并行技术

LLM训练”中的“分布式训练并行技术；分布式训练并行技术

目录 “LLM训练”中的“分布式训练并行技术” 分布式训练并行技术 数据并行 流水线并行:按阶段（stage）进行切分 张量并行 序列并行 多维混合并行 自动并行 MOE并行 重要的分布式AI框架 “LLM训练”中的“分布式训练并行技术” 随着深度学习技术的不断发展，特别是…
阅读更多...
论文阅读：Computational Long Exposure Mobile Photography (二)

论文阅读：Computational Long Exposure Mobile Photography (二)

这篇文章是谷歌发表在 2023 ACM transaction on Graphic 上的一篇文章，介绍如何在手机摄影中实现长曝光的一些拍摄效果。 Abstract 长曝光摄影能拍出令人惊叹的影像，用运动模糊来呈现场景中的移动元素。它通常有两种模式，分别产生前景模糊或…
阅读更多...
测试概念以及测试bug

测试概念以及测试bug

关于测试的概念 什么是需求？ 需求分为用户需求和软件需求。 软件需求可以作为开发和测试工作的依据，而用户需求不一定是合理的，这里的不合理有很多的角度：技术角度上，市场需求上，投入成本和收益比噔噔。…
阅读更多...
mac m1 docker本地部署canal 监听mysql的binglog日志

mac m1 docker本地部署canal 监听mysql的binglog日志

mac m1 docker本地部署canal监听mysql的binglog日志(虚拟机同理) 根据黑马视频部署 1.docker 部署mysql 1.docker拉取mysql 镜像 因为m1是arm架构.需要多加一条信息 正常拉取 docker pull mysql:tagm1拉取 5.7的版本. tag需要自己指定版本 docker pull --platform linux/x…
阅读更多...
C++之旅——入门

C++之旅——入门

Hello，各位小伙伴们，前几期我们学习了C语言和数据结构，有了一定的基础之后我们来挑战新的语言——C。 目录 一、初识C 1>C发展历史 2>C版本更新 3>C的热度 4>C的学习难度 5>C学习相关书籍 二、第一个C代码 三、C基础 …
阅读更多...
Flutter中文字体设置指南：打造个性化的应用体验

Flutter中文字体设置指南：打造个性化的应用体验

在使用Flutter进行开发时，可能会遇到中文字体显示不正常或者字体不符合设计需求的情况。Flutter默认的中文字体往往无法满足某些用户对个性化和美观的需求。今天，我们就来详细探讨如何在Flutter应用中设置中文字体，并结合不同场景提供相应的解…
阅读更多...
4.1 软件设计概要

4.1 软件设计概要

软件设计概要 1、 软件设计的概念和设计质量1.1 软件设计基本任务1.2 设计模型1.3 软件设计特点1.4 设计质量属性1.5 设计指导原则 2、 设计相关八大概念抽象体系结构设计模式模块化信息隐藏功能独立精化重构 3、 四类设计技术概要3.1 数据设计3.2 体系架构设计体系结构组织和细…
阅读更多...
MySQL表的增删改查(CRUD2)

MySQL表的增删改查(CRUD2)

美好的一天又开始了，大家今天有没有学习呢？没学的话，开始跟随和博主一起对MYSQL的学习吧！！！ 复习： CRUD新增1.新增 insert into 表名 [(列名[，列名,列名...])] values (值[,值,值.…
阅读更多...
用接地气的例子趣谈 WWDC 24 全新的 Swift Testing 入门（三）

用接地气的例子趣谈 WWDC 24 全新的 Swift Testing 入门（三）

概述 从 WWDC 24 开始，苹果推出了全新的测试机制：Swift Testing。利用它我们可以大幅度简化之前“老态龙钟”的 XCTest 编码范式，并且使得单元测试更加灵动自由，更符合 Swift 语言的优雅品味。 在这里我们会和大家一起初涉并领略…
阅读更多...
【案例】Excel使用宏来批量插入图片

【案例】Excel使用宏来批量插入图片

一、场景介绍 我有一个excel文件，需要通过一列的文件名称，按照规则给批量上传图片附件。 原始文件： 成功后文件： 二、实现方法 1. 使用【wps】工具打开Excel文件，将其保存为启用宏的文件。 2.找到编辑宏的【VB编辑器…
阅读更多...
Springboot项目报错记录

Springboot项目报错记录

SpringBoot测试报错：Unable to find a SpringBootConfiguration, you need to use Context 该测试类所在测试包test下的包名和类路径java下的包名不一致导致的 引发以下报错 java.lang.IllegalStateException: Unable to find a SpringBootConfiguration, you need…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023