自学教程：C++ HAL_Delay函数代码示例

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* STM32F4xx HAL library initialization:       - Configure the Flash prefetch, instruction and Data caches       - Configure the Systick to generate an interrupt each 1 msec       - Set NVIC Group Priority to 4       - Global MSP (MCU Support Package) initialization     */  HAL_Init();    /* Configure the system clock to 168 MHz */  SystemClock_Config();    /* Configure LED1, LED2, LED3 and LED4 */  BSP_LED_Init(LED1);  BSP_LED_Init(LED2);  BSP_LED_Init(LED3);  BSP_LED_Init(LED4);    /* Configure Key Button */    BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);    /*##-1- Configure the CAN peripheral #######################################*/  CAN_Config();    /*##-2- Start the Reception process and enable reception interrupt #########*/  if(HAL_CAN_Receive_IT(&CanHandle, CAN_FIFO0) != HAL_OK)  {    /* Reception Error */    Error_Handler();  }      /* Infinite loop */  while(1)  {    while(BSP_PB_GetState(BUTTON_KEY) == KEY_PRESSED)    {      if(ubKeyNumber == 0x4)       {        ubKeyNumber = 0x00;      }      else      {        LED_Display(++ubKeyNumber);        /* Set the data to be transmitted */        CanHandle.pTxMsg->Data[0] = ubKeyNumber;        CanHandle.pTxMsg->Data[1] = 0xAD;        /*##-3- Start the Transmission process ###############################*/        if(HAL_CAN_Transmit(&CanHandle, 10) != HAL_OK)        {          /* Transmission Error */          Error_Handler();        }        HAL_Delay(10);        while(BSP_PB_GetState(BUTTON_KEY) != KEY_NOT_PRESSED)        {        }      }    }  } }

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* STM32F4xx HAL library initialization:       - Configure the Flash prefetch, instruction and Data caches       - Configure the Systick to generate an interrupt each 1 msec       - Set NVIC Group Priority to 4       - Global MSP (MCU Support Package) initialization     */  HAL_Init();  /* Configure LED1, LED2, LED3 and LED4 */  BSP_LED_Init(LED1);  BSP_LED_Init(LED2);  BSP_LED_Init(LED3);  BSP_LED_Init(LED4);    /* Configure Key Button, used to trigger an interrupt each time it's pressed.    In the ISR the PLL source will be changed from HSE to HSI, and vice versa. */  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_EXTI);    /* Enable Power Control clock */  __HAL_RCC_PWR_CLK_ENABLE();  /* The voltage scaling allows optimizing the power consumption when the device is      clocked below the maximum system frequency, to update the voltage scaling value      regarding system frequency refer to product datasheet.  */  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);     /* Enable HSE oscillator and configure the PLL to reach the max system frequency (180MHz)     when using HSE oscillator as PLL clock source. */  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 = 360;  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;  RCC_OscInitStruct.PLL.PLLQ = 7;  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }    /* Activate the Over Drive feature (available only for STM32F42xxx/43xxx devices)*/  if(HAL_PWREx_EnableOverDrive() != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }    /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2 clocks dividers.     The SysTick 1 msec interrupt is required for the HAL process (Timeout management); by default     the configuration is done using the HAL_Init() API, and when the system clock configuration     is updated the SysTick configuration will be adjusted by the HAL_RCC_ClockConfig() API. */  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;    if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }    /* Output SYSCLK divided by 2 on MCO2 pin(PC9) */   HAL_RCC_MCOConfig(RCC_MCO2, RCC_MCO2SOURCE_SYSCLK, RCC_MCODIV_2);  /* Toggle some LEDs in an infinite loop */    while (1)  {   /* Toggle LED1 */    BSP_LED_Toggle(LED1);    HAL_Delay(100);    /* Toggle LED2 */    BSP_LED_Toggle(LED2);    HAL_Delay(100);    /* Toggle LED4 */    BSP_LED_Toggle(LED4);    HAL_Delay(100);  }}

/**  * @brief  GPIO EXTI Callback function  *         Handle remote-wakeup through key button  * @param  GPIO_Pin  * @retval None  */void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin){  if (GPIO_Pin == KEY_BUTTON_PIN)  {#if (USBD_LPM_ENABLED == 1)    if(hpcd.lpm_active)    {      if(hpcd.LPM_State == LPM_L1)      {        if ((&hpcd)->Init.low_power_enable)        {          /* Reset SLEEPDEEP bit of Cortex System Control Register */          SCB->SCR &= (uint32_t)~((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));                      SystemClockConfig_STOP();        }                /* Ungate PHY clock */        __HAL_PCD_UNGATE_PHYCLOCK((&hpcd));                /* Activate Remote wakeup */        HAL_PCD_ActivateRemoteWakeup((&hpcd));                /* Remote wakeup delay */        HAL_Delay(10);                /* Disable Remote wakeup */        HAL_PCD_DeActivateRemoteWakeup((&hpcd));                /* change state to configured */        ((USBD_HandleTypeDef *)hpcd.pData)->dev_state = USBD_STATE_CONFIGURED;                /* clear L1 flag */        hpcd.LPM_State = LPM_L0;      }      else#endif        if ((((USBD_HandleTypeDef *)hpcd.pData)->dev_remote_wakeup == 1)&&            (((USBD_HandleTypeDef *)hpcd.pData)->dev_state == USBD_STATE_SUSPENDED))        {          if ((&hpcd)->Init.low_power_enable)          {            /* Reset SLEEPDEEP bit of Cortex System Control Register */            SCB->SCR &= (uint32_t)~((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));                          SystemClockConfig_STOP();          }                    /* Ungate PHY clock */          __HAL_PCD_UNGATE_PHYCLOCK((&hpcd));                    /* Activate Remote wakeup */          HAL_PCD_ActivateRemoteWakeup((&hpcd));                    /* Remote wakeup delay */          HAL_Delay(10);                    /* Disable Remote wakeup */          HAL_PCD_DeActivateRemoteWakeup((&hpcd));                    /* change state to configured */          ((USBD_HandleTypeDef *)hpcd.pData)->dev_state = USBD_STATE_CONFIGURED;                    /* Change remote_wakeup feature to 0*/          ((USBD_HandleTypeDef *)hpcd.pData)->dev_remote_wakeup=0;        }    }  }}

/**  * @brief  Delay routine for the USB Host Library  * @param  Delay: Delay in ms  * @retval None  */void USBH_Delay(uint32_t Delay){  HAL_Delay(Delay);  }

/**  * @brief  Configures the selected DAC channel.  * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains  *         the configuration information for the specified DAC.  * @param  sConfig: DAC configuration structure.  * @param  Channel: The selected DAC channel.   *          This parameter can be one of the following values:  *            @arg DAC_CHANNEL_1: DAC Channel1 selected  *            @arg DAC_CHANNEL_2: DAC Channel2 selected  * @retval HAL status  */HAL_StatusTypeDef HAL_DAC_ConfigChannel(DAC_HandleTypeDef* hdac, DAC_ChannelConfTypeDef* sConfig, uint32_t Channel){  uint32_t tmpreg1 = 0, tmpreg2 = 0;  uint32_t tickstart = 0;     /* Check the DAC parameters */  assert_param(IS_DAC_TRIGGER(sConfig->DAC_Trigger));  assert_param(IS_DAC_OUTPUT_BUFFER_STATE(sConfig->DAC_OutputBuffer));  assert_param(IS_DAC_CHIP_CONNECTION(sConfig->DAC_ConnectOnChipPeripheral));  assert_param(IS_DAC_TRIMMING(sConfig->DAC_UserTrimming));  if ((sConfig->DAC_UserTrimming) == DAC_TRIMMING_USER)  {    assert_param(IS_DAC_TRIMMINGVALUE(sConfig->DAC_TrimmingValue));                 }  assert_param(IS_DAC_SAMPLEANDHOLD(sConfig->DAC_SampleAndHold));  if ((sConfig->DAC_SampleAndHold) == DAC_SAMPLEANDHOLD_ENABLE)  {    assert_param(IS_DAC_SAMPLETIME(sConfig->DAC_SampleAndHoldConfig.DAC_SampleTime));    assert_param(IS_DAC_HOLDTIME(sConfig->DAC_SampleAndHoldConfig.DAC_HoldTime));    assert_param(IS_DAC_REFRESHTIME(sConfig->DAC_SampleAndHoldConfig.DAC_RefreshTime));   }  assert_param(IS_DAC_CHANNEL(Channel));   /* Process locked */  __HAL_LOCK(hdac);    /* Change DAC state */  hdac->State = HAL_DAC_STATE_BUSY;    if(sConfig->DAC_SampleAndHold == DAC_SAMPLEANDHOLD_ENABLE)  /* Sample on old configuration */   {    /* SampleTime */    if (Channel == DAC_CHANNEL_1)    {      /* Get timeout */      tickstart = HAL_GetTick();            /* SHSR1 can be written when BWST1  equals RESET */      while (((hdac->Instance->SR) & DAC_SR_BWST1)!= RESET)      {        /* Check for the Timeout */        if((HAL_GetTick() - tickstart) > TIMEOUT_DAC_CALIBCONFIG)        {          /* Update error code */          SET_BIT(hdac->ErrorCode, HAL_DAC_ERROR_TIMEOUT);          /* Change the DMA state */          hdac->State = HAL_DAC_STATE_TIMEOUT;          return HAL_TIMEOUT;        }      }      HAL_Delay(1);      hdac->Instance->SHSR1 = sConfig->DAC_SampleAndHoldConfig.DAC_SampleTime;    }    else /* Channel 2 */    {      /* SHSR2 can be written when BWST2 equals RESET */      while (((hdac->Instance->SR) & DAC_SR_BWST2)!= RESET)      {        /* Check for the Timeout */        if((HAL_GetTick() - tickstart) > TIMEOUT_DAC_CALIBCONFIG)        {          /* Update error code */          SET_BIT(hdac->ErrorCode, HAL_DAC_ERROR_TIMEOUT);          /* Change the DMA state */          hdac->State = HAL_DAC_STATE_TIMEOUT;          return HAL_TIMEOUT;        }      }      HAL_Delay(1);      hdac->Instance->SHSR2 = sConfig->DAC_SampleAndHoldConfig.DAC_SampleTime;    }    /* HoldTime */    hdac->Instance->SHHR = (sConfig->DAC_SampleAndHoldConfig.DAC_HoldTime)<<Channel;    /* RefreshTime */    hdac->Instance->SHRR = (sConfig->DAC_SampleAndHoldConfig.DAC_RefreshTime)<<Channel;  }      if(sConfig->DAC_UserTrimming == DAC_TRIMMING_USER)  /* USER TRIMMING */  {  /* Get the DAC CCR value */  tmpreg1 = hdac->Instance->CCR;  /* Clear trimming value *///.........这里部分代码省略.........

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* STM32F4xx HAL library initialization:       - Configure the Flash prefetch, instruction and Data caches       - Configure the Systick to generate an interrupt each 1 msec       - Set NVIC Group Priority to 4       - Global MSP (MCU Support Package) initialization     */  HAL_Init();    /* Configure LED3, LED4, LED5 and LED6 */  BSP_LED_Init(LED3);  BSP_LED_Init(LED4);  BSP_LED_Init(LED5);  BSP_LED_Init(LED6);  /* Configure the system clock to 84 MHz */  SystemClock_Config();  /*##-1- Configure the UART peripheral ######################################*/  /* Put the USART peripheral in the Asynchronous mode (UART Mode) */  /* UART1 configured as follow:      - Word Length = 8 Bits      - Stop Bit = One Stop bit      - Parity = None      - BaudRate = 9600 baud      - Hardware flow control disabled (RTS and CTS signals) */  UartHandle.Instance          = USARTx;    UartHandle.Init.BaudRate     = 9600;  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;  UartHandle.Init.StopBits     = UART_STOPBITS_1;  UartHandle.Init.Parity       = UART_PARITY_NONE;  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;  UartHandle.Init.Mode         = UART_MODE_TX_RX;  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;      if(HAL_UART_Init(&UartHandle) != HAL_OK)  {    Error_Handler();  }  #ifdef TRANSMITTER_BOARD  /* Configure USER Button */  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);	  /* Wait for USER Button press before starting the Communication */  while (BSP_PB_GetState(BUTTON_KEY) == RESET)  {    /* Toggle LED3 waiting for user to press button */    BSP_LED_Toggle(LED3);    HAL_Delay(40);		  }  /* Wait for USER Button to be release before starting the Communication */  while (BSP_PB_GetState(BUTTON_KEY) == SET)  {  }    /* Turn LED3 off */  BSP_LED_Off(LED3);  /* The board sends the message and expects to receive it back */    /*##-2- Start the transmission process #####################################*/    /* While the UART in reception process, user can transmit data through      "aTxBuffer" buffer */  if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 5000)!= HAL_OK)  {    Error_Handler();     }    /* Turn LED6 on: Transfer in transmission process is correct */  BSP_LED_On(LED6);    /*##-3- Put UART peripheral in reception process ###########################*/    if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE, 5000) != HAL_OK)  {    Error_Handler();    }      /* Turn LED4 on: Transfer in reception process is correct */  BSP_LED_On(LED4);  #else    /* The board receives the message and sends it back */  /*##-2- Put UART peripheral in reception process ###########################*/  if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE, 5000) != HAL_OK)  {    Error_Handler();      }  //.........这里部分代码省略.........

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  uint8_t  lcd_status = LCD_OK;  /* STM32F4xx HAL library initialization:    - Configure the Flash prefetch, instruction and Data caches    - Systick timer is configured by default as source of time base, but user      can eventually implement his proper time base source (a general purpose      timer for example or other time source), keeping in mind that Time base      duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and      handled in milliseconds basis.    - Set NVIC Group Priority to 4    - Low Level Initialization: global MSP (MCU Support Package) initialization  */  HAL_Init();  /* Configure the system clock to 180 MHz */  SystemClock_Config();  /* Initialize the SDRAM */  BSP_SDRAM_Init();  /* Initialize the LCD   */  lcd_status = LCD_Init();  OnError_Handler(lcd_status != LCD_OK);  /* Initialize LTDC layer 0 iused for Hint */  LCD_LayertInit(0, LAYER0_ADDRESS);  BSP_LCD_SelectLayer(0);  HAL_DSI_LongWrite(&hdsi_eval, 0, DSI_DCS_LONG_PKT_WRITE, 4, OTM8009A_CMD_CASET, pColLeft);  HAL_DSI_LongWrite(&hdsi_eval, 0, DSI_DCS_LONG_PKT_WRITE, 4, OTM8009A_CMD_PASET, pPage);  /* Update pitch : the draw is done on the whole physical X Size */  HAL_LTDC_SetPitch(&hltdc_eval, BSP_LCD_GetXSize(), 0);  /* Display example brief   */  LCD_BriefDisplay();  /* Show first image */  CopyPicture((uint32_t *)Images[ImageIndex++], (uint32_t *)LAYER0_ADDRESS, 240, 160, 320, 240);  pending_buffer = 0;  active_area = LEFT_AREA;  HAL_DSI_LongWrite(&hdsi_eval, 0, DSI_DCS_LONG_PKT_WRITE, 2, OTM8009A_CMD_WRTESCN, pScanCol);  /* Infinite loop */  while (1)  {    if(pending_buffer < 0)    {      CopyPicture((uint32_t *)Images[ImageIndex++], (uint32_t *)LAYER0_ADDRESS, 240, 160, 320, 240);      if(ImageIndex >= 2)      {        ImageIndex = 0;      }      pending_buffer = 1;      HAL_DSI_LongWrite(&hdsi_eval, 0, DSI_DCS_LONG_PKT_WRITE, 2, OTM8009A_CMD_WRTESCN, pScanCol);    }    /* Wait some time before switching to next image */    HAL_Delay(2000);  }}

/**  * @brief  Wait for loop in ms.  * @param  Delay in ms.  * @retval None  */void LCD_Delay(uint32_t Delay){  HAL_Delay(Delay);}

/**  * @brief  IOE Delay.  * @param  Delay in ms  * @retval None  */void IOE_Delay(uint32_t Delay){  HAL_Delay(Delay);}

HAL_StatusTypeDef HAL_OPAMP_SelfCalibrate(OPAMP_HandleTypeDef *hopamp){   HAL_StatusTypeDef status = HAL_OK;    uint32_t trimmingvaluen = 0;  uint32_t trimmingvaluep = 0;  uint32_t delta;  uint32_t opampmode;    __IO uint32_t* tmp_opamp_reg_trimming;   /* Selection of register of trimming depending on power mode: OTR or LPOTR */      /* Check the OPAMP handle allocation */  /* Check if OPAMP locked */  if((hopamp == NULL) || (hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED))  {    status = HAL_ERROR;  }  else  {    /* Check if OPAMP in calibration mode and calibration not yet enable */    if(hopamp->State ==  HAL_OPAMP_STATE_READY)    {      /* Check the parameter */      assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));      assert_param(IS_OPAMP_POWERMODE(hopamp->Init.PowerMode));      /* Save OPAMP mode as in                                       */      /* STM32L471xx STM32L475xx STM32L476xx STM32L485xx STM32L486xx */      /* the calibration is not working in PGA mode                  */      opampmode = READ_BIT(hopamp->Instance->CSR,OPAMP_CSR_OPAMODE);            /* Use of standalone mode */       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_OPAMODE, OPAMP_STANDALONE_MODE);       /*  user trimming values are used for offset calibration */      SET_BIT(hopamp->Instance->CSR, OPAMP_CSR_USERTRIM);            /* Select trimming settings depending on power mode */      if (hopamp->Init.PowerMode == OPAMP_POWERMODE_NORMAL)      {        tmp_opamp_reg_trimming = &hopamp->Instance->OTR;      }      else      {        tmp_opamp_reg_trimming = &hopamp->Instance->LPOTR;      }            /* Enable calibration */      SET_BIT (hopamp->Instance->CSR, OPAMP_CSR_CALON);        /* 1st calibration - N */      CLEAR_BIT (hopamp->Instance->CSR, OPAMP_CSR_CALSEL);            /* Enable the selected opamp */      SET_BIT (hopamp->Instance->CSR, OPAMP_CSR_OPAMPxEN);            /* Init trimming counter */          /* Medium value */      trimmingvaluen = 16;       delta = 8;                 while (delta != 0)      {        /* Set candidate trimming */        /* OPAMP_POWERMODE_NORMAL */        MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OTR_TRIMOFFSETN, trimmingvaluen);                /* OFFTRIMmax delay 1 ms as per datasheet (electrical characteristics */         /* Offset trim time: during calibration, minimum time needed between */        /* two steps to have 1 mV accuracy */        HAL_Delay(OPAMP_TRIMMING_DELAY);        if (READ_BIT(hopamp->Instance->CSR, OPAMP_CSR_CALOUT) != RESET)        {           /* OPAMP_CSR_CALOUT is HIGH try higher trimming */          trimmingvaluen -= delta;        }        else        {          /* OPAMP_CSR_CALOUT is LOW try lower trimming */          trimmingvaluen += delta;        }        /* Divide range by 2 to continue dichotomy sweep */               delta >>= 1;      }      /* Still need to check if right calibration is current value or one step below */      /* Indeed the first value that causes the OUTCAL bit to change from 0 to 1  */      /* Set candidate trimming */      MODIFY_REG(*tmp_opamp_reg_trimming, OPAMP_OTR_TRIMOFFSETN, trimmingvaluen);                 /* OFFTRIMmax delay 1 ms as per datasheet (electrical characteristics */       /* Offset trim time: during calibration, minimum time needed between */      /* two steps to have 1 mV accuracy */      HAL_Delay(OPAMP_TRIMMING_DELAY);            if ((READ_BIT(hopamp->Instance->CSR, OPAMP_CSR_CALOUT)) == 0)      {         /* Trimming value is actually one value more *///.........这里部分代码省略.........

/**  * @brief  Demo application for IAP through USB mass storage.     * @param  None  * @retval None  */void FW_UPGRADE_Process(void){  switch(Demo_State)  {  case DEMO_INIT:    /* Register the file system object to the FatFs module */    if(f_mount(&USBH_fatfs, "", 0 ) != FR_OK )    {      /* FatFs initialization fails */      /* Toggle LED3 and LED4 in infinite loop */      FatFs_Fail_Handler();    }        /* TO DO */        //    /* Flash Disk is write protected: Turn LED4 On and Toggle LED3 in infinite loop */    //    if(USBH_MSC_Param.MSWriteProtect == DISK_WRITE_PROTECTED)    //    {    //      /* Turn LED4 On */    //      BSP_LED_On(LED4);    //      /* Toggle LED3 in infinite loop */    //      Fail_Handler();    //    }        /* Go to IAP menu */    Demo_State = DEMO_IAP;    break;      case DEMO_IAP:    while(USBH_MSC_IsReady(&hUSBHost))    {        /* Control BUFFER_SIZE value */      USBH_USR_BufferSizeControl();            /* Keep LED1 and LED3 Off when Device connected */      BSP_LED_Off(LED3);       BSP_LED_Off(LED4);             /* USER Button pressed Delay */      IAP_UploadTimeout();            /* Writes Flash memory */      COMMAND_Download();            /* Check if USER Button is already pressed */      if((UploadCondition == 0x01))      {        /* Reads all flash memory */        COMMAND_Upload();      }      else      {        /* Turn LED4 Off: Download Done */        BSP_LED_Off(LED4);         /* Turn LED3 On: Waiting KEY button pressed */        BSP_LED_On(LED3);       }            /* Waiting USER Button Released */      while((BSP_PB_GetState(BUTTON_KEY) == GPIO_PIN_RESET) && (Appli_state == APPLICATION_READY))      {}            /* Waiting USER Button Pressed */      while((BSP_PB_GetState(BUTTON_KEY) != GPIO_PIN_RESET) && (Appli_state == APPLICATION_READY))      {}            /* Waiting USER Button Released */      while((BSP_PB_GetState(BUTTON_KEY) == GPIO_PIN_RESET) && (Appli_state == APPLICATION_READY))      {}            if(Appli_state == APPLICATION_READY)      {        /* Jump to user application code located in the internal Flash memory */        COMMAND_Jump();      }    }         break;      default:    break;  }  if(Appli_state == APPLICATION_DISCONNECT)  {    /* Toggle LED3: USB device disconnected */    BSP_LED_Toggle(LED4);    HAL_Delay(100);  }}

//.........这里部分代码省略.........  /* Reset touch data information */  BSP_TEST_APPLI_ASSERT(BSP_TS_ResetTouchData(&TS_State));  /* If calibration is not yet done, proceed with calibration */  if (TouchScreen_IsCalibrationDone() == 0)  {    ts_status = Touchscreen_Calibration();    if (ts_status == TS_OK)    {      BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 65, (uint8_t *) "Touchscreen calibration success.", CENTER_MODE);    }  } /* of if (TouchScreen_IsCalibrationDone() == 0) */  if(ts_status == TS_OK)  {    /* Display touch screen demo description */    Touchscreen_SetHint_Demo(TOUCHSCREEN_DEMO_1);    Touchscreen_DrawBackground_Demo1(state);    while (exitTsUseCase == 0)    {      if (ts_status == TS_OK)      {        /* Check in polling mode in touch screen the touch status and coordinates */        /* of touches if touch occurred                                           */        ts_status = BSP_TS_GetState(&TS_State);        if(TS_State.touchDetected)        {          /* One or dual touch have been detected          */          /* Only take into account the first touch so far */          /* Get X and Y position of the first touch post calibrated */          x1 = TouchScreen_Get_Calibrated_X(TS_State.touchX[0]);          y1 = TouchScreen_Get_Calibrated_Y(TS_State.touchY[0]);          if ((y1 > (CIRCLE_YPOS(1) - CIRCLE_RADIUS)) &&              (y1 < (CIRCLE_YPOS(1) + CIRCLE_RADIUS)))          {            if ((x1 > (CIRCLE_XPOS(1) - CIRCLE_RADIUS)) &&                (x1 < (CIRCLE_XPOS(1) + CIRCLE_RADIUS)))            {              if ((state & 1) == 0)              {                Touchscreen_DrawBackground_Demo1(state);                BSP_LCD_SetTextColor(LCD_COLOR_BLUE);                BSP_LCD_FillCircle(CIRCLE_XPOS(1), CIRCLE_YPOS(1), CIRCLE_RADIUS);                state = 1;              }            }            if ((x1 > (CIRCLE_XPOS(2) - CIRCLE_RADIUS)) &&                (x1 < (CIRCLE_XPOS(2) + CIRCLE_RADIUS)))            {              if ((state & 2) == 0)              {                Touchscreen_DrawBackground_Demo1(state);                BSP_LCD_SetTextColor(LCD_COLOR_RED);                BSP_LCD_FillCircle(CIRCLE_XPOS(2), CIRCLE_YPOS(2), CIRCLE_RADIUS);                state = 2;              }            }            if ((x1 > (CIRCLE_XPOS(3) - CIRCLE_RADIUS)) &&                (x1 < (CIRCLE_XPOS(3) + CIRCLE_RADIUS)))            {              if ((state & 4) == 0)              {                Touchscreen_DrawBackground_Demo1(state);                BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);                BSP_LCD_FillCircle(CIRCLE_XPOS(3), CIRCLE_YPOS(3), CIRCLE_RADIUS);                state = 4;              }            }            if ((x1 > (CIRCLE_XPOS(4) - CIRCLE_RADIUS)) &&                (x1 < (CIRCLE_XPOS(4) + CIRCLE_RADIUS)))            {              if ((state & 8) == 0)              {                Touchscreen_DrawBackground_Demo1(state);                BSP_LCD_SetTextColor(LCD_COLOR_GREEN);                BSP_LCD_FillCircle(CIRCLE_XPOS(4), CIRCLE_YPOS(3), CIRCLE_RADIUS);                state = 8;              }            }          }        } /* of if(TS_State.TouchDetected) */      } /* of if (ts_status == TS_OK) */      /* Wait for a key button press to switch to next test case of BSP validation application */      /* Otherwise stay in the test */      exitTsUseCase = CheckForUserInput();      HAL_Delay(20);    } /* of while (exitTsUseCase == 0) */  } /* of if(status == TS_OK) */}

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* STM32F4xx HAL library initialization:       - Configure the Flash prefetch, instruction and Data caches       - Systick timer is configured by default as source of time base, but user         can eventually implement his proper time base source (a general purpose         timer for example or other time source), keeping in mind that Time base         duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and         handled in milliseconds basis.       - Set NVIC Group Priority to 4       - Low Level Initialization: global MSP (MCU Support Package) initialization     */  HAL_Init();  /* Configure the system clock to 100 MHz */  SystemClock_Config();  /* Configure LED2 */  BSP_LED_Init(LED2);  /*##-1- Configure the UART peripheral ######################################*/  /* Put the USART peripheral in the Asynchronous mode (UART Mode) */  /* UART configured as follows:      - Word Length = 8 Bits      - Stop Bit = One Stop bit      - Parity = None      - BaudRate = 9600 baud      - Hardware flow control disabled (RTS and CTS signals) */  UartHandle.Instance        = USARTx;  UartHandle.Init.BaudRate   = 9600;  UartHandle.Init.WordLength = UART_WORDLENGTH_8B;  UartHandle.Init.StopBits   = UART_STOPBITS_1;  UartHandle.Init.Parity     = UART_PARITY_NONE;  UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;  UartHandle.Init.Mode       = UART_MODE_TX_RX;  if(HAL_UART_DeInit(&UartHandle) != HAL_OK)  {    Error_Handler();  }  if(HAL_UART_Init(&UartHandle) != HAL_OK)  {    Error_Handler();  }#ifdef TRANSMITTER_BOARD  /* Configure User push-button in Interrupt mode */  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_EXTI);  /* Wait for User push-button press before starting the Communication.     In the meantime, LED2 is blinking */  while(UserButtonStatus == 0)  {      /* Toggle LED2*/      BSP_LED_Toggle(LED2);      HAL_Delay(100);  }  BSP_LED_Off(LED2);  /* The board sends the message and expects to receive it back */  /*##-2- Start the transmission process #####################################*/  /* While the UART in reception process, user can transmit data through     "aTxBuffer" buffer */  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)  {    Error_Handler();  }  /*##-3- Wait for the end of the transfer ###################################*/  while (UartReady != SET)  {  }  /* Reset transmission flag */  UartReady = RESET;  /*##-4- Put UART peripheral in reception process ###########################*/  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)  {    Error_Handler();  }#else  /* The board receives the message and sends it back */  /*##-2- Put UART peripheral in reception process ###########################*/  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)  {    Error_Handler();  }//.........这里部分代码省略.........

/**  * @brief  Manages MSC Menu Process.  * @param  None  * @retval None  */void MSC_MenuProcess(void){  switch(msc_demo.state)  {  case MSC_DEMO_START:    if(Appli_state == APPLICATION_READY)    {      BSP_LCD_SetTextColor(LCD_COLOR_GREEN);      BSP_LCD_DisplayStringAtLine(19, (uint8_t *)"Press User button to start read and write operations");            /* Wait for User Input */      while((BSP_PB_GetState(BUTTON_WAKEUP) != SET) && (Appli_state != APPLICATION_DISCONNECT))      {      }      msc_demo.state = MSC_DEMO_FILE_OPERATIONS;            /* Prevent debounce effect for user key */      HAL_Delay(400);            BSP_LCD_ClearStringLine(19);    }    break;      case MSC_DEMO_FILE_OPERATIONS:    /* Read and Write File Here */    if(Appli_state == APPLICATION_READY)    {      MSC_File_Operations();            BSP_LCD_SetTextColor(LCD_COLOR_GREEN);      BSP_LCD_DisplayStringAtLine(19, (uint8_t *)"Press User button to display disk content");            /* Wait for User Input */      while((BSP_PB_GetState(BUTTON_WAKEUP) != SET) && (Appli_state != APPLICATION_DISCONNECT))      {      }      msc_demo.state = MSC_DEMO_EXPLORER;            /* Prevent debounce effect for user key */      HAL_Delay(400);            BSP_LCD_ClearStringLine(19);    }    break;       case MSC_DEMO_EXPLORER:    /* Display disk content */    if(Appli_state == APPLICATION_READY)    {      Explore_Disk("0:/", 1);      msc_demo.state = MSC_DEMO_START;            /* Prevent debounce effect for user key */      HAL_Delay(400);    }    break;      default:    break;  }    if(Appli_state == APPLICATION_DISCONNECT)  {    Appli_state = APPLICATION_IDLE;    LCD_LOG_ClearTextZone();    LCD_ErrLog("MSC device disconnected!/n");    msc_demo.state = MSC_DEMO_START;    msc_demo.select = 0;  }}

/**  * @brief  Joystick demo  * @param  None  * @retval None  */void Joystick_demo (void){   static uint16_t xPtr = 12;  static uint16_t yPtr = 92;  static uint16_t old_xPtr = 12;  static uint16_t old_yPtr = 92;    Joystick_SetHint();    BSP_JOY_Init(JOY_MODE_GPIO);    while (1)  {    /* Get the Joystick State */    JoyState = BSP_JOY_GetState();        switch(JoyState)    {    case JOY_UP:      if(yPtr > 92)      {        yPtr--;      }      break;         case JOY_DOWN:        if(yPtr < (BSP_LCD_GetYSize() - 12 - 11))      {        yPtr++;      }      break;              case JOY_LEFT:      if(xPtr > 12)      {        xPtr--;      }      break;             case JOY_RIGHT:        if(xPtr < (BSP_LCD_GetXSize() - 8 - 11))      {        xPtr++;      }      break;                     default:      break;               }        BSP_LCD_SetBackColor(LCD_COLOR_WHITE);    BSP_LCD_SetTextColor(LCD_COLOR_BLUE);        if(JoyState == JOY_SEL)    {      BSP_LCD_SetTextColor(LCD_COLOR_RED);      BSP_LCD_DisplayChar(xPtr, yPtr, 'X');          }    else if(JoyState == JOY_NONE)    {      BSP_LCD_SetTextColor(LCD_COLOR_BLUE);      BSP_LCD_DisplayChar(xPtr, yPtr, 'X');       }    else    {      BSP_LCD_SetTextColor(LCD_COLOR_WHITE);      BSP_LCD_DisplayChar(old_xPtr, old_yPtr, 'X');      BSP_LCD_SetTextColor(LCD_COLOR_BLUE);       BSP_LCD_DisplayChar(xPtr, yPtr, 'X');            old_xPtr = xPtr;      old_yPtr = yPtr;    }    if(CheckForUserInput() > 0)    {      return;    }    HAL_Delay(5);  }}

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* STM32F4xx HAL library initialization:       - Configure the Flash prefetch, instruction and Data caches       - Configure the Systick to generate an interrupt each 1 msec       - Set NVIC Group Priority to 4       - Global MSP (MCU Support Package) initialization     */  HAL_Init();  /* Configure the system clock to 100 MHz */  SystemClock_Config();  /* Configure LED2 */  BSP_LED_Init(LED2);  /*##-1- Configure the I2C peripheral ######################################*/  I2cHandle.Instance             = I2Cx;  I2cHandle.Init.AddressingMode  = I2C_ADDRESSINGMODE_10BIT;  I2cHandle.Init.ClockSpeed      = 400000;  I2cHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;  I2cHandle.Init.DutyCycle       = I2C_DUTYCYCLE_16_9;  I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;  I2cHandle.Init.NoStretchMode   = I2C_NOSTRETCH_DISABLE;  I2cHandle.Init.OwnAddress1     = I2C_ADDRESS;  I2cHandle.Init.OwnAddress2     = 0xFE;  if(HAL_I2C_Init(&I2cHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }#ifdef MASTER_BOARD  /* Configure USER Button */  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);  /* Wait for USER Button press before starting the Communication */  while (BSP_PB_GetState(BUTTON_KEY) == 1)  {    /* Toggle LED2 every 1sec */    BSP_LED_Toggle(LED2);    HAL_Delay(1000);  }  /* Wait for USER Button release before starting the Communication */  while (BSP_PB_GetState(BUTTON_KEY) == 0)  {  }  BSP_LED_Off(LED2);  /* The board sends the message and expects to receive it back */  /*##-2- Start the transmission process #####################################*/  /* While the I2C in reception process, user can transmit data through     "aTxBuffer" buffer */  while(HAL_I2C_Master_Transmit_DMA(&I2cHandle, (uint16_t)I2C_ADDRESS, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)  {    /* Error_Handler() function is called when Timeout error occurs.       When Acknowledge failure occurs (Slave don't acknowledge it's address)       Master restarts communication */    if (HAL_I2C_GetError(&I2cHandle) != HAL_I2C_ERROR_AF)    {      Error_Handler();    }  }  /*##-3- Wait for the end of the transfer ###################################*/  /*  Before starting a new communication transfer, you need to check the current      state of the peripheral; if it’s busy you need to wait for the end of current      transfer before starting a new one.      For simplicity reasons, this example is just waiting till the end of the      transfer, but application may perform other tasks while transfer operation      is ongoing. */  while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY)  {  }  /* Wait for USER Button press before starting the Communication */  while (BSP_PB_GetState(BUTTON_KEY) == 1)  {    /* Toggle LED2 every 1sec */    BSP_LED_Toggle(LED2);    HAL_Delay(1000);  }  /* Wait for USER Button release before starting the Communication */  while (BSP_PB_GetState(BUTTON_KEY) == 0)  {  }  BSP_LED_Off(LED2);//.........这里部分代码省略.........

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* STM32F4xx HAL library initialization:       - Configure the Flash prefetch, instruction and Data caches       - Configure the Systick to generate an interrupt each 1 msec       - Set NVIC Group Priority to 4       - Global MSP (MCU Support Package) initialization     */  HAL_Init();    /* Configure LED3, LED4, LED5 and LED6 */  BSP_LED_Init(LED3);  BSP_LED_Init(LED4);  BSP_LED_Init(LED5);  BSP_LED_Init(LED6);    /* Configure the system clock to 84 MHz */  SystemClock_Config();    /* Enable Power Clock */  __HAL_RCC_PWR_CLK_ENABLE();    /* Check and handle if the system was resumed from StandBy mode */  if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET)  {    __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);        /* Turn LED4 On */    BSP_LED_On(LED4);  }  /* Configure USER Button */  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_EXTI);  /* Infinite loop */  while(1)  {    UserButtonStatus = 0;    /* Wait until USER Button is pressed to enter the Low Power mode */    while(UserButtonStatus == 0)    {      /* Toggle LED6 */      BSP_LED_Toggle(LED6);            /* Inserted Delay */      HAL_Delay(100);    }    /* Loop while USER Button is maintained pressed */    while(BSP_PB_GetState(BUTTON_KEY) != RESET)    {    }#if defined (SLEEP_MODE)    /* Sleep Mode Entry     - System Running at PLL (168MHz)    - Flash 5 wait state    - Instruction and Data caches ON    - Prefetch ON    - Code running from Internal FLASH    - All peripherals disabled.    - Wake-up using EXTI Line (USER Button PA.00)    */    SleepMode_Measure();#elif defined (STOP_MODE)    /* STOP Mode Entry     - RTC Clocked by LSI    - Regulator in LP mode    - HSI, HSE OFF and LSI OFF if not used as RTC Clock source      - No IWDG    - FLASH in deep power down mode    - Automatic Wake-up using RTC clocked by LSI (after ~20s)    */    StopMode_Measure();#elif defined (STANDBY_MODE)    /* STANDBY Mode Entry     - Backup SRAM and RTC OFF    - IWDG and LSI OFF    - Wake-up using WakeUp Pin (PA.00)    */    StandbyMode_Measure();    #elif defined (STANDBY_RTC_MODE)    /* STANDBY Mode with RTC on LSI Entry     - RTC Clocked by LSI    - IWDG OFF and LSI OFF if not used as RTC Clock source    - Backup SRAM OFF    - Automatic Wake-up using RTC clocked by LSI (after ~20s)    */    StandbyRTCMode_Measure();    #elif defined (STANDBY_RTC_BKPSRAM_MODE)    /* STANDBY Mode with RTC on LSI Entry     - RTC Clocked by LSI    - Backup SRAM ON//.........这里部分代码省略.........

/**  * @brief  Animation demo  * @param  None  * @retval None  */void Animation_demo (void){  uint32_t exit = 0;  uint32_t CameraChangeResolutionAsked = 1;#ifdef USE_CAMERA_IN_ANIMATION  uint32_t camera_status = CAMERA_OK;  uint32_t argb8888_Value = 0x00556677;  uint32_t CameraResX = CAMERA_VGA_RES_X;  uint32_t CameraResY = CAMERA_VGA_RES_Y;#endif /* USE_CAMERA_IN_ANIMATION */  Animation_SetHint();  /*## Camera Initialization and start capture ############################*/  BSP_LCD_SetBackColor(LCD_COLOR_BLUE);  BSP_LCD_SetTextColor(LCD_COLOR_WHITE);#ifdef USE_CAMERA_IN_ANIMATION  BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - ANIMATION_STATUS_TEXT_POS, (uint8_t *)"Wait for camera initialization...", CENTER_MODE);#endif /* USE_CAMERA_IN_ANIMATION */  /* Infinite loop */  while (exit == 0)  {    if(CameraChangeResolutionAsked)  /* A camera change resolution has been asked */    {      CameraChangeResolutionAsked = 0;      BSP_LCD_SetBackColor(LCD_COLOR_WHITE);      BSP_LCD_SetTextColor(LCD_COLOR_BLUE);#ifdef USE_CAMERA_IN_ANIMATION      /* Initialize the Camera */      camera_status = BSP_CAMERA_Init(RESOLUTION_R640x480);      BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - ANIMATION_STATUS_TEXT_POS, (uint8_t *)"        VGA camera stream        ", CENTER_MODE);      if (camera_status != CAMERA_OK)      {        BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - ANIMATION_STATUS_TEXT_POS - 15, (uint8_t *)"        CAMERA INIT ERROR        ", CENTER_MODE);      }#endif /* USE_CAMERA_IN_ANIMATION */      /* Clear first the LCD */      BSP_LCD_Clear(LCD_COLOR_WHITE);#ifdef USE_CAMERA_IN_ANIMATION      /* Init or Re-Init Camera frame buffer by using DMA2D engine in mode Register to Memory */      camera_status = AnimationCameraFrameBufferRgb565_Init(CameraResX,                                                            CameraResY,                                                            argb8888_Value);      BSP_TEST_APPLI_ASSERT(camera_status != CAMERA_OK);      /* Start / Restart camera stream */      BSP_CAMERA_ContinuousStart((uint8_t *)CAMERA_FB_START_ADDR);#endif /* USE_CAMERA_IN_ANIMATION */      /* Forbid in that case the DMA2D copy from Camera frame buffer to LCD Frame buffer location by BSP_CAMERA_LineEventCallback() */      Camera_AllowDma2dCopyCamFrmBuffToLcdFrmBuff = 0;    }  /* of if (CameraChangeResolutionAsked) */    /* Toggle LED4 */    BSP_LED_Toggle(LED4);    /* Insert 100 ms delay */    HAL_Delay(100);    /* Toggle LED2 */    BSP_LED_Toggle(LED2);    /* Insert 400 ms delay */    HAL_Delay(400);    if(CheckForUserInput() > 0)    {      exit = 1;    }    anime_draw_scene(anime_lcd_frame_buffer);  } /* of while (exit == 0) */#ifdef USE_CAMERA_IN_ANIMATION  /* Stop camera stream */  camera_status = BSP_CAMERA_Stop();  BSP_TEST_APPLI_ASSERT(camera_status != CAMERA_OK);#endif /* USE_CAMERA_IN_ANIMATION */}

/**  * @brief  Execute the demo application.  * @param  None  * @retval None  */static void Demo_Exec(void){  uint8_t togglecounter = 0x00;  /* Initialize Accelerometer MEMS*/  if(BSP_ACCELERO_Init() != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }  while(1)  {    DemoEnterCondition = 0x00;    /* Reset UserButton_Pressed variable */    UserButtonPressed = 0x00;    /* Configure LEDs to be managed by GPIO */    BSP_LED_Init(LED3);    BSP_LED_Init(LED4);    BSP_LED_Init(LED5);    BSP_LED_Init(LED6);    /* SysTick end of count event each 10ms */    SystemCoreClock = HAL_RCC_GetHCLKFreq();    SysTick_Config(SystemCoreClock / 100);    /* Turn OFF all LEDs */    BSP_LED_Off(LED4);    BSP_LED_Off(LED3);    BSP_LED_Off(LED5);    BSP_LED_Off(LED6);    /* Waiting User Button is pressed */    while (UserButtonPressed == 0x00)    {      /* Toggle LED4 */      BSP_LED_Toggle(LED4);      HAL_Delay(10);      /* Toggle LED4 */      BSP_LED_Toggle(LED3);      HAL_Delay(10);      /* Toggle LED4 */      BSP_LED_Toggle(LED5);      HAL_Delay(10);      /* Toggle LED4 */      BSP_LED_Toggle(LED6);      HAL_Delay(10);      togglecounter ++;      if (togglecounter == 0x10)      {        togglecounter = 0x00;        while (togglecounter < 0x10)        {          BSP_LED_Toggle(LED4);          BSP_LED_Toggle(LED3);          BSP_LED_Toggle(LED5);          BSP_LED_Toggle(LED6);          HAL_Delay(10);          togglecounter ++;        }        togglecounter = 0x00;      }    }    /* Waiting User Button is Released */    while (BSP_PB_GetState(BUTTON_KEY) != KEY_NOT_PRESSED)    {}    UserButtonPressed = 0x00;    /* TIM4 channels configuration */    TIM4_Config();    DemoEnterCondition = 0x01;    /* USB configuration */    Demo_USBConfig();    /* Waiting User Button is pressed */    while (UserButtonPressed == 0x00)    {}    /* Waiting User Button is Released */    while (BSP_PB_GetState(BUTTON_KEY) != KEY_NOT_PRESSED)    {}    /* Disconnect the USB device */    USBD_Stop(&hUSBDDevice);    USBD_DeInit(&hUSBDDevice);    if(HAL_TIM_PWM_DeInit(&htim4) != HAL_OK)    {      /* Initialization Error */      Error_Handler();    }//.........这里部分代码省略.........

//.........这里部分代码省略.........    /* Configure LED3 */  BSP_LED_Init(LED3);  /* Configure Key Button*/  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);  /*##-1- Initialize the LCD #################################################*/  BSP_LCD_Init();     /*##-2- Display welcome messages on LCD ####################################*/    Display_ExampleDescription();  /* Wait for Key Button press before starting the Example */  while (BSP_PB_GetState(BUTTON_KEY) != GPIO_PIN_RESET)  {  }    /* Wait for Key Button release before starting the Example */  while (BSP_PB_GetState(BUTTON_KEY) != GPIO_PIN_SET)  {  }  /*##-3- Display Example Template ###########################################*/    TSENSOR_SetHint();  /*##-4- Configure the Temperature Sensor ###################################*/  /* Conversion 12 bits in continuous mode at one conversion per second */  /* Alert outside range Limit Temperature */  TSENSOR_InitStructure.AlertMode             = TSENSOR_ALERT_ENABLE;  TSENSOR_InitStructure.ConversionMode        = TSENSOR_CONTINUOUS_MODE;  TSENSOR_InitStructure.ConversionResolution  = TSENSOR_CONV_12BITS;  TSENSOR_InitStructure.ConversionRate        = TSENSOR_ONE_PER_SECOND;             TSENSOR_InitStructure.TemperatureLimitHigh  = TEMPERATURE_HIGH;  TSENSOR_InitStructure.TemperatureLimitLow   = TEMPERATURE_LOW;  if (TSENSOR_Init(TSENSOR_ADDR, &TSENSOR_InitStructure) != TSENSOR_OK)  {    /* Initialization Error */    BSP_LCD_SetTextColor(LCD_COLOR_RED);        BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"Initialization problem", CENTER_MODE);     BSP_LCD_DisplayStringAt(0, 130, (uint8_t*)"Verify that jumper JP5 and JP6", CENTER_MODE);    BSP_LCD_DisplayStringAt(0, 145, (uint8_t*)"are well set to I2C2 position", CENTER_MODE);    Error_Handler();  }  /* Initialize tick counter */  tick = HAL_GetTick();    /*##-5- Main loop to manage Alert and display Temperature Measured #########*/  while (1)  {    /* Check if a new temperature read is requested to display                */    if (requestsample == 1)    {      /* Read and Display the current temperature                             */      temperaturevalue = TSENSOR_ReadTemp(TSENSOR_ADDR);      TSENSOR_Display_Temperature(temperaturevalue);            /* Reset the sampling request                                           */      tick = HAL_GetTick();      requestsample = 0;    }    else    {      /* Request a Temperature sampling each 1s <-> 1000 ms                   */      if (HAL_GetTick() >= tick + 1000)      {        /* Set the sampling request                                           */        requestsample = 1;      }    }        /* Check if an alert occurs                                               */    if (alertoccurs == 1)    {      /* Get the Address of temperature sensor in Alert Mode                  */      addressalert = TSENSOR_AlerteResponseAddressRead();            /* Display warning message depends on Limit value                       */      if ((TSENSOR_ReadStatus(addressalert) & TSENSOR_TEMP_EXCEED_HIGH_LIMIT) == TSENSOR_TEMP_EXCEED_HIGH_LIMIT)      {        BSP_LCD_SetTextColor(LCD_COLOR_RED);        /* Display warning message Temperature high limit exceeded            */        BSP_LCD_DisplayStringAt(0, 160, (uint8_t *)"Temperature Limit High", CENTER_MODE);        BSP_LCD_DisplayStringAt(0, 175, (uint8_t *)"has been exceeded", CENTER_MODE);      }      else      {        BSP_LCD_SetTextColor(LCD_COLOR_BLUE);        /* Display warning message Temperature is at or blow low limit        */        BSP_LCD_DisplayStringAt(0, 160, (uint8_t *)"Temperature is at or", CENTER_MODE);        BSP_LCD_DisplayStringAt(0, 175, (uint8_t *)"below the Low Limit", CENTER_MODE);      }      alertoccurs = 0;    }            HAL_Delay(5);  }}

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){#ifdef MASTER_BOARD  GPIO_InitTypeDef  GPIO_InitStruct;#endif  /* STM32F3xx HAL library initialization:       - Configure the Flash prefetch       - Configure the Systick to generate an interrupt each 1 msec       - Set NVIC Group Priority to 4       - Low Level Initialization     */  HAL_Init();    /* Configure the system clock to 64 MHz */  SystemClock_Config();  /* Configure LED3 */  BSP_LED_Init(LED3);    /*##-1- Configure the I2C peripheral ######################################*/  I2cHandle.Instance             = I2Cx;  I2cHandle.Init.Timing          = I2C_TIMING;  I2cHandle.Init.OwnAddress1     = I2C_ADDRESS;  I2cHandle.Init.AddressingMode  = I2C_ADDRESSINGMODE_10BIT;  I2cHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;  I2cHandle.Init.OwnAddress2     = 0xFF;  I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;  I2cHandle.Init.NoStretchMode   = I2C_NOSTRETCH_DISABLE;      if(HAL_I2C_Init(&I2cHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }    /* Enable the Analog I2C Filter */  HAL_I2CEx_ConfigAnalogFilter(&I2cHandle,I2C_ANALOGFILTER_ENABLE);#ifdef MASTER_BOARD    /* Configure PA.12 (Arduino D2) button */  GPIO_InitStruct.Pin = GPIO_PIN_12;  GPIO_InitStruct.Pull = GPIO_PULLUP;  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;      /* Enable GPIOA clock */  __HAL_RCC_GPIOA_CLK_ENABLE();  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);  /* Wait Until PA.12 (Arduino D2) is connected to GND */  while(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12) != GPIO_PIN_RESET)   {  }    /* Wait Until PA.12 (Arduino D2) is de-connected from GND */  while(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12) != GPIO_PIN_SET)  {  }       /* The board sends the message and expects to receive it back */    /*##-2- Start the transmission process #####################################*/    /* While the I2C in reception process, user can transmit data through      "aTxBuffer" buffer */  while(HAL_I2C_Master_Transmit_IT(&I2cHandle, (uint16_t)I2C_ADDRESS, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)  {    /* Error_Handler() function is called when Timeout error occurs.       When Acknowledge failure occurs (Slave don't acknowledge its address)       Master restarts communication */    if (HAL_I2C_GetError(&I2cHandle) != HAL_I2C_ERROR_AF)    {      Error_Handler();    }  }    /*##-3- Wait for the end of the transfer ###################################*/    /*  Before starting a new communication transfer, you need to check the current         state of the peripheral; if it’s busy you need to wait for the end of current      transfer before starting a new one.      For simplicity reasons, this example is just waiting till the end of the      transfer, but application may perform other tasks while transfer operation      is ongoing. */  while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY)  {  }     HAL_Delay(1000);  /* Wait Until PA.12 (Arduino D2) is connected to GND */  while(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12) != GPIO_PIN_RESET)   {//.........这里部分代码省略.........

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* STM32F0xx HAL library initialization:       - Configure the Flash prefetch       - Systick timer is configured by default as source of time base, but user          can eventually implement his proper time base source (a general purpose          timer for example or other time source), keeping in mind that Time base          duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and          handled in milliseconds basis.       - Low Level Initialization     */  HAL_Init();    /* Configure LED3, LED4, LED5 and LED6 */  BSP_LED_Init(LED3);  BSP_LED_Init(LED4);  BSP_LED_Init(LED5);  BSP_LED_Init(LED6);  /* Configure the system clock to 168 Mhz */  SystemClock_Config();  /*##-1- Configure the UART peripheral ######################################*/  /* Put the USART peripheral in the Asynchronous mode (UART Mode) */  /* UART configured as follows:      - Word Length = 8 Bits      - Stop Bit = One Stop bit      - Parity = None      - BaudRate = 9600 baud      - Hardware flow control disabled (RTS and CTS signals) */  UartHandle.Instance        = USARTx;  UartHandle.Init.BaudRate   = 9600;  UartHandle.Init.WordLength = UART_WORDLENGTH_8B;  UartHandle.Init.StopBits   = UART_STOPBITS_1;  UartHandle.Init.Parity     = UART_PARITY_NONE;  UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;  UartHandle.Init.Mode       = UART_MODE_TX_RX;  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;  if(HAL_UART_DeInit(&UartHandle) != HAL_OK)  {    Error_Handler();  }    if(HAL_UART_Init(&UartHandle) != HAL_OK)  {    Error_Handler();  }  #ifdef TRANSMITTER_BOARD  /* Configure User push-button in Interrupt mode */  BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);    /* Wait for User push-button press before starting the Communication.     In the meantime, LED4 is blinking */  while(UserButtonStatus == 0)  {      /* Toggle LED4*/      BSP_LED_Toggle(LED4);       HAL_Delay(100);  }    BSP_LED_Off(LED4);       /* The board sends the message and expects to receive it back */    /*##-2- Start the transmission process #####################################*/    /* While the UART in reception process, user can transmit data through      "aTxBuffer" buffer */  if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 5000)!= HAL_OK)  {    Error_Handler();     }    /* Turn LED6 on: Transfer in transmission process is correct */  BSP_LED_On(LED6);    /*##-3- Put UART peripheral in reception process ###########################*/    if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE, 5000) != HAL_OK)  {    Error_Handler();    }     /* Turn LED5 on: Transfer in reception process is correct */  BSP_LED_On(LED5); #else    /* The board receives the message and sends it back */  /*##-2- Put UART peripheral in reception process ###########################*/  if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE, 0x1FFFFFF) != HAL_OK)//.........这里部分代码省略.........

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* STM32F4xx HAL library initialization:       - Configure the Flash prefetch, instruction and Data caches       - Configure the Systick to generate an interrupt each 1 msec       - Set NVIC Group Priority to 4       - Global MSP (MCU Support Package) initialization     */  HAL_Init();  /* Configure the system clock to 168 MHz */  SystemClock_Config();  /* Configure LED1 and LED3 */  BSP_LED_Init(LED1);  BSP_LED_Init(LED3);  /* Initialize TIM3 to emulate a quadrature encoder outputs */  Init_TIM_Emulator(&EmulatorHandle);  /* -1- Initialize TIM1 to handle the encoder sensor */  /* Initialize TIM1 peripheral as follow:       + Period = 65535       + Prescaler = 0       + ClockDivision = 0       + Counter direction = Up  */  Encoder_Handle.Instance = TIM1;  Encoder_Handle.Init.Period            = 65535;  Encoder_Handle.Init.Prescaler         = 0;  Encoder_Handle.Init.ClockDivision     = 0;  Encoder_Handle.Init.CounterMode       = TIM_COUNTERMODE_UP;  Encoder_Handle.Init.RepetitionCounter = 0;  sEncoderConfig.EncoderMode        = TIM_ENCODERMODE_TI12;  sEncoderConfig.IC1Polarity        = TIM_ICPOLARITY_RISING;  sEncoderConfig.IC1Selection       = TIM_ICSELECTION_DIRECTTI;  sEncoderConfig.IC1Prescaler       = TIM_ICPSC_DIV1;  sEncoderConfig.IC1Filter          = 0;  sEncoderConfig.IC2Polarity        = TIM_ICPOLARITY_RISING;  sEncoderConfig.IC2Selection       = TIM_ICSELECTION_DIRECTTI;  sEncoderConfig.IC2Prescaler       = TIM_ICPSC_DIV1;  sEncoderConfig.IC2Filter          = 0;  if(HAL_TIM_Encoder_Init(&Encoder_Handle, &sEncoderConfig) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }  /* Start the encoder interface */  HAL_TIM_Encoder_Start(&Encoder_Handle, TIM_CHANNEL_ALL);  /* Infinite loop */  while (1)  {    /* Step 1: */    /* Emulate a Forward direction */    Emulate_Forward_Direction(&EmulatorHandle);    /* Insert 1s delay */    HAL_Delay(1000);    /* Get the current direction */    uwDirection = __HAL_TIM_IS_TIM_COUNTING_DOWN(&Encoder_Handle);    /* Step 2: */    /* Emulate a Backward direction */    Emulate_Backward_Direction(&EmulatorHandle);    /* Insert 1s delay */    HAL_Delay(1000);    /* Get the current direction */    uwDirection = __HAL_TIM_IS_TIM_COUNTING_DOWN(&Encoder_Handle);  }}

/**  * @brief  Transmit a file using the ymodem protocol  * @param  p_buf: Address of the first byte  * @param  p_file_name: Name of the file sent  * @param  file_size: Size of the transmission  * @retval COM_StatusTypeDef result of the communication  */COM_StatusTypeDef Ymodem_Transmit (uint8_t *p_buf, const uint8_t *p_file_name, uint32_t file_size){  uint32_t errors = 0, ack_recpt = 0, size = 0, pkt_size;  uint8_t *p_buf_int;  COM_StatusTypeDef result = COM_OK;  uint32_t blk_number = 1;  uint8_t a_rx_ctrl[2];  uint8_t i;#ifdef CRC16_F      uint32_t temp_crc;#else /* CRC16_F */     uint8_t temp_chksum;#endif /* CRC16_F */    /* Prepare first block - header */  PrepareIntialPacket(aPacketData, p_file_name, file_size);  while (( !ack_recpt ) && ( result == COM_OK ))  {    /* Send Packet */    HAL_UART_Transmit(&UartHandle, &aPacketData[PACKET_START_INDEX], PACKET_SIZE + PACKET_HEADER_SIZE, NAK_TIMEOUT);    /* Send CRC or Check Sum based on CRC16_F */#ifdef CRC16_F        temp_crc = Cal_CRC16(&aPacketData[PACKET_DATA_INDEX], PACKET_SIZE);    Serial_PutByte(temp_crc >> 8);    Serial_PutByte(temp_crc & 0xFF);#else /* CRC16_F */       temp_chksum = CalcChecksum (&aPacketData[PACKET_DATA_INDEX], PACKET_SIZE);    Serial_PutByte(temp_chksum);#endif /* CRC16_F */    /* Wait for Ack and 'C' */    if (HAL_UART_Receive(&UartHandle, &a_rx_ctrl[0], 1, NAK_TIMEOUT) == HAL_OK)    {      if (a_rx_ctrl[0] == ACK)      {        ack_recpt = 1;      }      else if (a_rx_ctrl[0] == CA)      {        if ((HAL_UART_Receive(&UartHandle, &a_rx_ctrl[0], 1, NAK_TIMEOUT) == HAL_OK) && (a_rx_ctrl[0] == CA))        {          HAL_Delay( 2 );          __HAL_UART_FLUSH_DRREGISTER(&UartHandle);          result = COM_ABORT;        }      }    }    else    {      errors++;    }    if (errors >= MAX_ERRORS)    {      result = COM_ERROR;    }  }  p_buf_int = p_buf;  size = file_size;  /* Here 1024 bytes length is used to send the packets */  while ((size) && (result == COM_OK ))  {    /* Prepare next packet */    PreparePacket(p_buf_int, aPacketData, blk_number, size);    ack_recpt = 0;    a_rx_ctrl[0] = 0;    errors = 0;    /* Resend packet if NAK for few times else end of communication */    while (( !ack_recpt ) && ( result == COM_OK ))    {      /* Send next packet */      if (size >= PACKET_1K_SIZE)      {        pkt_size = PACKET_1K_SIZE;      }      else      {        pkt_size = PACKET_SIZE;      }      HAL_UART_Transmit(&UartHandle, &aPacketData[PACKET_START_INDEX], pkt_size + PACKET_HEADER_SIZE, NAK_TIMEOUT);            /* Send CRC or Check Sum based on CRC16_F */#ifdef CRC16_F          temp_crc = Cal_CRC16(&aPacketData[PACKET_DATA_INDEX], pkt_size);      Serial_PutByte(temp_crc >> 8);      Serial_PutByte(temp_crc & 0xFF);#else /* CRC16_F */         temp_chksum = CalcChecksum (&aPacketData[PACKET_DATA_INDEX], pkt_size);//.........这里部分代码省略.........

//.........这里部分代码省略.........    Error_Handler();  }#endif /* ADC_TRIGGER_FROM_TIMER */#if defined(WAVEFORM_VOLTAGE_GENERATION_FOR_TEST)  /* Set DAC Channel data register: channel corresponding to ADC channel CHANNELa */  /* Set DAC output to 1/2 of full range (4095 <=> Vdda=3.3V): 2048 <=> 1.65V              */  if (HAL_DAC_SetValue(&DacHandle, DACx_CHANNEL_TO_ADCx_CHANNELa, DAC_ALIGN_12B_R, RANGE_12BITS/2) != HAL_OK)  {    /* Setting value Error */    Error_Handler();  }    /* Enable DAC Channel: channel corresponding to ADC channel CHANNELa */  if (HAL_DAC_Start(&DacHandle, DACx_CHANNEL_TO_ADCx_CHANNELa) != HAL_OK)  {    /* Start Error */    Error_Handler();  }#endif /* WAVEFORM_VOLTAGE_GENERATION_FOR_TEST */  /*## Start ADC conversions #################################################*/    /* Start ADC conversion on regular group with transfer by DMA */  if (HAL_ADC_Start_DMA(&AdcHandle,                        (uint32_t *)aADCxConvertedValues,                        ADCCONVERTEDVALUES_BUFFER_SIZE                       ) != HAL_OK)  {    /* Start Error */    Error_Handler();  }      /* Infinite loop */  while (1)  {    /* Wait for event on push button to perform following actions */    while ((ubUserButtonClickEvent) == RESET)    {    }    /* Reset variable for next loop iteration */    ubUserButtonClickEvent = RESET;        /* Start ADC conversion on injected group */    if (HAL_ADCEx_InjectedStart_IT(&AdcHandle) != HAL_OK)    {      /* Start Conversation Error */      Error_Handler();    }    #if defined(WAVEFORM_VOLTAGE_GENERATION_FOR_TEST)    /* Set DAC voltage on channel corresponding to ADCx_CHANNELa              */    /* in function of user button clicks count.                               */    /* Set DAC output successively to:                                        */    /*  - minimum of full range (0 <=> ground 0V)                             */    /*  - 1/4 of full range (4095 <=> Vdda=3.3V): 1023 <=> 0.825V             */    /*  - 1/2 of full range (4095 <=> Vdda=3.3V): 2048 <=> 1.65V              */    /*  - 3/4 of full range (4095 <=> Vdda=3.3V): 3071 <=> 2.475V             */    /*  - maximum of full range (4095 <=> Vdda=3.3V)                          */    if (HAL_DAC_SetValue(&DacHandle,                         DACx_CHANNEL_TO_ADCx_CHANNELa,                         DAC_ALIGN_12B_R,                         (RANGE_12BITS * ubUserButtonClickCount / USERBUTTON_CLICK_COUNT_MAX)                        ) != HAL_OK)    {      /* Start Error */      Error_Handler();    }#endif /* WAVEFORM_VOLTAGE_GENERATION_FOR_TEST */    /* Wait for acquisition time of ADC samples on regular and injected       */    /* groups:                                                                */    /* wait time to let 1/2 buffer of regular group to be filled (in ms)      */    HAL_Delay(16);        /* Turn-on/off LED3 in function of ADC conversion result */    /* - Turned-off if voltage measured by injected group is below voltage    */    /*   measured by regular group (average of results table)                 */    /* - Turned-off if voltage measured by injected group is above voltage    */    /*   measured by regular group (average of results table)                 */        /* Variables of conversions results are updated into ADC conversions      */    /* interrupt callback.                                                    */    if (uhADCxConvertedValue_Injected < *puhADCxConvertedValue_Regular_Avg)    {      BSP_LED_Off(LED3);    }    else    {      BSP_LED_On(LED3);    }      /* For information: ADC conversion results are stored into array          */    /* "aADCxConvertedValues" (for debug: check into watch window)            */      }}

/**  * @brief  Save the picture in USB Disk.  * @param  None  * @retval None  */void Save_Picture(void){  FRESULT res1, res2;    /* FatFs function common result code */  uint32_t byteswritten; /* File write count */  static uint32_t color;  /* Get the current text color */  color = BSP_LCD_GetTextColor();  BSP_LCD_SetTextColor(LCD_COLOR_DARKRED);  BSP_LCD_SetFont(&Font20);  /* Turn LED1 and LED3 Off */  BSP_LED_Off(LED1);  BSP_LED_Off(LED3);  if (Appli_state == APPLICATION_RUNNIG)  {    BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()-35), (uint8_t *)"Saving ... ", RIGHT_MODE);    /*##-1- Prepare the image to be saved ####################################*/    Prepare_Picture();    /*##-2- Create and Open a new bmp file object with write access ##########*/    if(f_open(&MyFile, "image.bmp", FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)    {      /* 'image.bmp' file Open for write Error */      Error_Handler();    }    else    {      /*##-3- Write data to the BMP file #####################################*/      /* Write the BMP header */      if (BSP_LCD_GetXSize() == 640)      {        /* if ampire 640x480 LCD is used */        res1 = f_write(&MyFile, (uint32_t *)aBMPHeader1, 54, (void *)&byteswritten);      }      else      {        /* if ampire 480x272 LCD is used */        res1 = f_write(&MyFile, (uint32_t *)aBMPHeader2, 54, (void *)&byteswritten);      }      /* Write the bmp file */      res2 = f_write(&MyFile, (uint32_t *)CONVERTED_FRAME_BUFFER, ((BSP_LCD_GetYSize()-60)*(BSP_LCD_GetXSize()-60)*3), (void *)&byteswritten);      if((res1 != FR_OK) || (res2 != FR_OK) || (byteswritten == 0))      {        /* 'image' file Write or EOF Error */        BSP_LED_On(LED3);        BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()-35), (uint8_t *)" Aborted...", RIGHT_MODE);        /* Wait for 2s */        HAL_Delay(2000);      }      else      {        /*##-4- Close the open text file #####################################*/        f_close(&MyFile);        /* Success of the demo: no error occurrence */        BSP_LED_On(LED1);        BSP_LCD_SetTextColor(LCD_COLOR_DARKGREEN);        BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()-35), (uint8_t *)" Saved     ", RIGHT_MODE);        /* Wait for 2s */        HAL_Delay(2000);      }    }  }  else  {    /* USB not connected */    BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()-35), (uint8_t *)"USB KO... ", RIGHT_MODE);    /* Wait for 2s */    HAL_Delay(2000);  }  BSP_LCD_SetTextColor(LCD_COLOR_WHITE);  BSP_LCD_FillRect(480, 430, 160, 50);  BSP_LCD_SetTextColor(color);}

//.........这里部分代码省略.........  * @retval None  */void Touchscreen_demo(void){   uint16_t x,y;  uint8_t status = 0;  uint8_t state = 0;    if(IsCalibrationDone() == 0)  {    Touchscreen_Calibration();  }    Touchscreen_SetHint();    status = BSP_TS_Init(BSP_LCD_GetXSize(), BSP_LCD_GetYSize());    if (status != TS_OK)  {    BSP_LCD_SetBackColor(LCD_COLOR_WHITE);     BSP_LCD_SetTextColor(LCD_COLOR_RED);    BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 95, (uint8_t *)"ERROR", CENTER_MODE);    BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 80, (uint8_t *)"Touchscreen cannot be initialized", CENTER_MODE);  }  else  {    Touchscreen_DrawBackground(state);  }    while (1)  {    if (status == TS_OK)    {      BSP_TS_GetState(&TS_State);            x = Calibration_GetX(TS_State.x);      y = Calibration_GetX(TS_State.y);            if((TS_State.TouchDetected) &&          (y > (CIRCLE_YPOS(1) - CIRCLE_RADIUS))&&           (y < (CIRCLE_YPOS(1) + CIRCLE_RADIUS)))      {                if((x > (CIRCLE_XPOS(1) - CIRCLE_RADIUS))&&           (x < (CIRCLE_XPOS(1) + CIRCLE_RADIUS)))        {          if((state & 1) == 0)          {            Touchscreen_DrawBackground(state);            BSP_LCD_SetTextColor(LCD_COLOR_BLUE);             BSP_LCD_FillCircle(CIRCLE_XPOS(1), CIRCLE_YPOS(1), CIRCLE_RADIUS);            state = 1;          }        }        if((x > (CIRCLE_XPOS(2) - CIRCLE_RADIUS))&&           (x < (CIRCLE_XPOS(2) + CIRCLE_RADIUS)))        {          if((state & 2) == 0)          {                      Touchscreen_DrawBackground(state);            BSP_LCD_SetTextColor(LCD_COLOR_RED);             BSP_LCD_FillCircle(CIRCLE_XPOS(2), CIRCLE_YPOS(2), CIRCLE_RADIUS);            state = 2;          }                  }                if((x > (CIRCLE_XPOS(3) - CIRCLE_RADIUS))&&           (x < (CIRCLE_XPOS(3) + CIRCLE_RADIUS)))        {          if((state & 4) == 0)          {                       Touchscreen_DrawBackground(state);            BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);             BSP_LCD_FillCircle(CIRCLE_XPOS(3), CIRCLE_YPOS(3), CIRCLE_RADIUS);            state = 4;          }                    }                if((x > (CIRCLE_XPOS(4) - CIRCLE_RADIUS))&&           (x < (CIRCLE_XPOS(4) + CIRCLE_RADIUS)))        {          if((state & 8) == 0)          {                       Touchscreen_DrawBackground(state);            BSP_LCD_SetTextColor(LCD_COLOR_GREEN);             BSP_LCD_FillCircle(CIRCLE_XPOS(4), CIRCLE_YPOS(3), CIRCLE_RADIUS);            state = 8;          }                   }              }       }        if(CheckForUserInput() > 0)    {      return;    }        HAL_Delay(100);  }}

/**  * @brief  Show LCD Features  * @param  feature : feature index  * @retval None  */static void LCD_Show_Feature(uint8_t feature){  Point Points[]= {{20, 150}, {80, 150}, {80, 200}};  Point Points2[]= {{100, 150}, {160, 150}, {160, 200}};    BSP_LCD_SetBackColor(LCD_COLOR_WHITE);    BSP_LCD_SetTextColor(LCD_COLOR_WHITE);      BSP_LCD_FillRect(12, 92, BSP_LCD_GetXSize() - 24, BSP_LCD_GetYSize()- 104);  BSP_LCD_SetTextColor(LCD_COLOR_BLACK);  switch (feature)  {  case 0:    /* Text Feature */        BSP_LCD_DisplayStringAt(14, 100, (uint8_t *)"Left aligned Text", LEFT_MODE);     BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Center aligned Text", CENTER_MODE);     BSP_LCD_DisplayStringAt(14, 130, (uint8_t *)"Right aligned Text", RIGHT_MODE);     BSP_LCD_SetFont(&Font24);    BSP_LCD_DisplayStringAt(14, 180, (uint8_t *)"Font24", LEFT_MODE);     BSP_LCD_SetFont(&Font20);    BSP_LCD_DisplayStringAt(BSP_LCD_GetXSize()/2 -20, 180, (uint8_t *)"Font20", LEFT_MODE);     BSP_LCD_SetFont(&Font16);    BSP_LCD_DisplayStringAt(BSP_LCD_GetXSize() - 80, 184, (uint8_t *)"Font16", LEFT_MODE);     break;      case 1:        /* Draw misc. Shapes */    BSP_LCD_SetTextColor(LCD_COLOR_BLACK);     BSP_LCD_DrawRect(20, 100, 60 , 40);    BSP_LCD_FillRect(100, 100, 60 , 40);         BSP_LCD_SetTextColor(LCD_COLOR_GRAY);     BSP_LCD_DrawCircle(BSP_LCD_GetXSize() - 120, 120, 20);    BSP_LCD_FillCircle(BSP_LCD_GetXSize() - 40, 120, 20);        BSP_LCD_SetTextColor(LCD_COLOR_GREEN);     BSP_LCD_DrawPolygon(Points, 3);    BSP_LCD_FillPolygon(Points2, 3);        BSP_LCD_SetTextColor(LCD_COLOR_RED);     BSP_LCD_DrawEllipse(BSP_LCD_GetXSize() - 120, 170, 30, 20);    BSP_LCD_FillEllipse(BSP_LCD_GetXSize() - 50, 170, 30, 20);         BSP_LCD_SetTextColor(LCD_COLOR_BLACK);     BSP_LCD_DrawHLine(20, BSP_LCD_GetYSize() - 30, BSP_LCD_GetXSize() / 5);    BSP_LCD_DrawLine (BSP_LCD_GetXSize() - 150, BSP_LCD_GetYSize()- 20, BSP_LCD_GetXSize()- 20, BSP_LCD_GetYSize()- 50);    BSP_LCD_DrawLine (BSP_LCD_GetXSize() - 150, BSP_LCD_GetYSize()- 50, BSP_LCD_GetXSize()- 20, BSP_LCD_GetYSize()- 20);    break;      case 2:    /* Draw Bitmap */    BSP_LCD_DrawBitmap(20, 100, (uint8_t *)stlogo);    HAL_Delay(200);        BSP_LCD_DrawBitmap(BSP_LCD_GetXSize()/2 - 40, 100, (uint8_t *)stlogo);    HAL_Delay(200);            BSP_LCD_DrawBitmap(BSP_LCD_GetXSize()-100, 100, (uint8_t *)stlogo);    HAL_Delay(200);    BSP_LCD_DrawBitmap(20, BSP_LCD_GetYSize()- 80, (uint8_t *)stlogo);    HAL_Delay(200);        BSP_LCD_DrawBitmap(BSP_LCD_GetXSize()/2 - 40, BSP_LCD_GetYSize()- 80, (uint8_t *)stlogo);    HAL_Delay(200);         BSP_LCD_DrawBitmap(BSP_LCD_GetXSize()-100, BSP_LCD_GetYSize()- 80, (uint8_t *)stlogo);    HAL_Delay(200);        break;  }}

/**  * @brief  Delay routine for the USB Device Library  * @param  Delay: Delay in ms  * @retval None  */void  USBD_LL_Delay(uint32_t Delay){  HAL_Delay(Delay);}

/**  * @brief  Save the picture in USB Disk.  * @param  None  * @retval None  */void Save_Picture(void){   FRESULT res;           /* FatFs function common result code */  uint32_t bytesWritten; /* File write count */    BSP_LCD_SetLayerVisible(1, ENABLE);  BSP_LCD_SetColorKeying(1, LCD_COLOR_WHITE);  /* Set foreground Layer */  BSP_LCD_SelectLayer(1);  BSP_LCD_SetTextColor(LCD_COLOR_DARKRED);  BSP_LCD_SetFont(&Font20);    if (Appli_state == APPLICATION_START)  {    BSP_LCD_DisplayStringAt(10, (BSP_LCD_GetYSize()-100), (uint8_t *)"Saving ... ", RIGHT_MODE);        /*##-1- Prepare the image to be saved ####################################*/    Prepare_Picture();        /*##-2- Create and Open a new bmp file object with write access ##########*/    if(f_open(&MyFile, "image.bmp", FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)    {      /* 'image.bmp' file Open for write Error */      Error_Handler();    }    else    {      /*##-3- Write data to the BMP file #####################################*/      /* Write the BMP header */      res = f_write(&MyFile, (uint32_t *)aBMPHeader, 54, (void *)&bytesWritten);      /* Write the bmp file */      res = f_write(&MyFile, (uint32_t *)CONVERTED_FRAME_BUFFER, ((BSP_LCD_GetYSize()-60)*(BSP_LCD_GetXSize()-60)*3), (void *)&bytesWritten);            if((bytesWritten == 0) || (res != FR_OK))      {        /* 'image' file Write or EOF Error */        Error_Handler();      }      else      {        /*##-4- Close the open text file #####################################*/        f_close(&MyFile);                /* Success of the demo: no error occurrence */        BSP_LED_On(LED3);        BSP_LCD_SetTextColor(LCD_COLOR_DARKGREEN);        BSP_LCD_DisplayStringAt(10, (BSP_LCD_GetYSize()-100), (uint8_t *)"Save       ", RIGHT_MODE);        /* Wait for 2s */        HAL_Delay(2000);        /* Disable the Layer 2 */        BSP_LCD_SetLayerVisible(1, DISABLE);        /* Select Layer 1 */        BSP_LCD_SelectLayer(0);      }    }  }  else  {    /* USB not connected */    BSP_LCD_DisplayStringAt(10, (BSP_LCD_GetYSize()-100), (uint8_t *)"USB KO... ", RIGHT_MODE);    /* Wait for 2s */    HAL_Delay(2000);    /* Disable the Layer 2 */    BSP_LCD_SetLayerVisible(1, DISABLE);    /* Select Layer 1 */    BSP_LCD_SelectLayer(0);  }}