空的while(1){}有什么用？需要自己写吗？

#include "main.h"
#define PeriodValue             (uint32_t) (100 - 1)
#define PulseValue              (uint32_t) (50 - 1)

LPTIM_HandleTypeDef             LptimHandle;
RCC_PeriphCLKInitTypeDef        RCC_PeriphCLKInitStruct;
static void SystemClock_Config(void);
static HAL_StatusTypeDef LSE_ClockEnable(void);
static void Error_Handler(void);
static void CPU_CACHE_Enable(void);

int main(void)
{

  /* Enable the CPU Cache */
  CPU_CACHE_Enable();
  HAL_Init();

  /* Configure the system clock to 280 MHz */
  SystemClock_Config();

  /* Configure LED3 */
  BSP_LED_Init(LED3);
  
  /* User push-button (EXTI15_10) will be used to wakeup the system from Stop mode */
  BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);

  /* Enable the LSE Clock */
  if (LSE_ClockEnable() != HAL_OK)
  {
    Error_Handler();
  }

  LptimHandle.Instance = LPTIM1;
  
  LptimHandle.Init.Clock.Source    = LPTIM_CLOCKSOURCE_APBCLOCK_LPOSC;
  LptimHandle.Init.Clock.Prescaler = LPTIM_PRESCALER_DIV1;  
  LptimHandle.Init.CounterSource   = LPTIM_COUNTERSOURCE_INTERNAL;
  LptimHandle.Init.Trigger.Source  = LPTIM_TRIGSOURCE_SOFTWARE; 
  LptimHandle.Init.OutputPolarity  = LPTIM_OUTPUTPOLARITY_HIGH;
  LptimHandle.Init.UpdateMode      = LPTIM_UPDATE_IMMEDIATE;
  LptimHandle.Init.Input1Source    = LPTIM_INPUT1SOURCE_GPIO;
  LptimHandle.Init.Input2Source    = LPTIM_INPUT2SOURCE_GPIO;
  
  /* Initialize LPTIM peripheral according to the passed parameters */
  if (HAL_LPTIM_Init(&LptimHandle) != HAL_OK)
  {
    Error_Handler();
  }

  if (HAL_LPTIM_PWM_Start(&LptimHandle, PeriodValue, PulseValue) != HAL_OK)
  {
    Error_Handler();
  }
  
  HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI); 
  
  if (HAL_LPTIM_PWM_Stop(&LptimHandle) != HAL_OK)
  {
    Error_Handler();
  }

  /* Infinite Loop */
  while (1)
  {        
  }
    
}

static void SystemClock_Config(void)
{
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};

  /*!< Supply configuration update enable */
  HAL_PWREx_ConfigSupply(PWR_DIRECT_SMPS_SUPPLY);

> 
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE0);

  while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}

  /* Enable HSE Oscillator and activate PLL with HSE as source */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS;
  RCC_OscInitStruct.HSIState = RCC_HSI_OFF;
  RCC_OscInitStruct.CSIState = RCC_CSI_OFF;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;

  RCC_OscInitStruct.PLL.PLLM = 4;
  RCC_OscInitStruct.PLL.PLLN = 280;
  RCC_OscInitStruct.PLL.PLLFRACN = 0;
  RCC_OscInitStruct.PLL.PLLP = 2;
  RCC_OscInitStruct.PLL.PLLR = 2;
  RCC_OscInitStruct.PLL.PLLQ = 2;

  RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
  RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_1;
  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    /* Initialization Error */
    while(1);
  }

  /* Select PLL as system clock source and configure the bus clocks dividers */
  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_D1PCLK1 | RCC_CLOCKTYPE_PCLK1 | \
    RCC_CLOCKTYPE_PCLK2  | RCC_CLOCKTYPE_D3PCLK1);

  RCC_ClkInitStruct.SYSCLKSource   = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.SYSCLKDivider  = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.AHBCLKDivider  = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
  RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
  if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_6) != HAL_OK)
  {
    /* Initialization Error */
    while(1);
  }
}

static HAL_StatusTypeDef LSE_ClockEnable(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct;
  
  /* Enable LSE clock */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
  RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  return (HAL_RCC_OscConfig(&RCC_OscInitStruct));
}

static void Error_Handler(void)
{
  /* Turn LED3 on */
  BSP_LED_On(LED3);
  while (1)
  {
  }
}

static void CPU_CACHE_Enable(void)
{
  /* Enable I-Cache */
  SCB_EnableICache();

  /* Enable D-Cache */
  SCB_EnableDCache();
}

#ifdef  USE_FULL_ASSERT

void assert_failed(uint8_t *file, uint32_t line)
{
  /* 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) */

  /* Infinite loop */
  while (1)
  {
  }
}

在大多数情况下，它的作用就是在程序中设置一次暂停。

while（1）{}；//作用：会重复执行{}中的代码，有时候是为了实现一种是否符合要求的排除判断，如下例子：

/*输入候选者人数，若子啊1-100之间跳出循环进行后面的操作，若不在1-100之间说明输入有误，不跳出循环，而是执行清屏操作*/
while(1)
    {
        system("cls");//clrscr();清屏
        /*输入候选者的人数*/
        printf("Input the num of the electees in the election:");
        scanf("%d",&ElecteeNum);
        if( ElecteeNum>1&&ElecteeNum<MAX )
            break;
    }

用途：1. 单片机在不使用操作系统时，主程序一般都使用这种架构
2. 操作系统中的进程，执行任务时，有些也会使用这种架构
3. {}中的代码不停地检测某个条件，当条件符合时，跳出该循环，继续向下执行我们在单片机中使用while(1)，大部分还是为了防止程序跑飞，因为很多时候执行完某段程序后单片机的程序指针PC（就是程序指针）并不会停止，仍然会继续从ROM中读取指令并执行，这样一来可能会出现程序跑飞的情况，进而出现不确定的结果，我们加个while(1)就能让程序在执行完后在原地循环，相当于停在原地，防止跑飞。

main函数中，空的while（1）作用是防止程序退出，如果不加，执行完Erro_handler函数之后程序会直接退出。

让程序能跑，不然main函数执行一遍之后，程序就死掉了