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

/**  * @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 and LED3 */  BSP_LED_Init(LED1);  BSP_LED_Init(LED2);  BSP_LED_Init(LED3);  /*##-1- Configure the CRYP peripheral ######################################*/  /* Set the CRYP parameters */  CrypHandle.Instance = CRYP;  CrypHandle.Init.DataType = CRYP_DATATYPE_8B;  CrypHandle.Init.KeySize  = CRYP_KEYSIZE_128B;  CrypHandle.Init.pKey     = aAES128Key;  if(HAL_CRYP_Init(&CrypHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }  /*##-2- Start the AES encryption in ECB chaining mode with DMA #############*/  if(HAL_CRYP_AESECB_Encrypt_DMA(&CrypHandle, aPlaintext, DATA_SIZE, aEncryptedText) != HAL_OK)  {    /* Processing Error */    Error_Handler();  }  /*  Before starting a new process, 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      process, but application may perform other tasks while transfer operation      is ongoing. */  while (HAL_CRYP_GetState(&CrypHandle) != HAL_CRYP_STATE_READY)  {  }  /*##-3- Check the encrypted text with the expected one #####################*/  if(memcmp(aEncryptedText, aCyphertext, DATA_SIZE) != 0)  {    /* Wrong encryption: Turn LED2 on */    BSP_LED_On(LED2);  }  else  {    /* Right encryption: Turn LED1 on */    BSP_LED_On(LED1);  }  /* Deinitialize Crypto peripheral */  HAL_CRYP_DeInit(&CrypHandle);  /* Set the CRYP parameters */  CrypHandle.Init.DataType = CRYP_DATATYPE_8B;  CrypHandle.Init.KeySize  = CRYP_KEYSIZE_128B;  CrypHandle.Init.pKey     = aAES128Key;  if(HAL_CRYP_Init(&CrypHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }  /*##-4- Start the AES decryption in ECB chaining mode with DMA #############*/  if(HAL_CRYP_AESECB_Decrypt_DMA(&CrypHandle, aEncryptedText, DATA_SIZE, aDecryptedText) != HAL_OK)  {    /* Processing Error */    Error_Handler();  }  /*  Before starting a new process, 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      process, but application may perform other tasks while transfer operation      is ongoing. */  while (HAL_CRYP_GetState(&CrypHandle) != HAL_CRYP_STATE_READY)  {  }  /*##-5- Check the decrypted text with the expected one #####################*/  if(memcmp(aDecryptedText, aPlaintext, DATA_SIZE) != 0)  {    /* Wrong encryption: Turn LED2 on */    BSP_LED_On(LED2);//.........这里部分代码省略.........

/**  * @brief  This function notify user about link status changement.  * @param  netif: the network interface  * @retval None  */void ethernetif_notify_conn_changed(struct netif *netif){  struct ip_addr ipaddr;  struct ip_addr netmask;  struct ip_addr gw;  if(netif_is_link_up(netif))  {#ifdef USE_DHCP#ifndef USE_LCD    BSP_LED_Off(LED2);    BSP_LED_On(LED1);#endif /* USE_LCD */    /* Update DHCP state machine */    DHCP_state = DHCP_START;#else    IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);    IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1 , NETMASK_ADDR2, NETMASK_ADDR3);    IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);    #ifdef USE_LCD            uint8_t iptxt[20];    sprintf((char*)iptxt, "  %d.%d.%d.%d", IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);    BSP_LCD_ClearStringLine(7);    BSP_LCD_ClearStringLine(8);    BSP_LCD_ClearStringLine(9);    BSP_LCD_DisplayStringAtLine(8,(uint8_t *) "  Static IP address:");    BSP_LCD_DisplayStringAtLine(9,(uint8_t *) iptxt);#else    BSP_LED_Off(LED2);    BSP_LED_On(LED1);#endif /* USE_LCD */#endif /* USE_DHCP */           netif_set_addr(netif, &ipaddr , &netmask, &gw);        /* When the netif is fully configured this function must be called.*/    netif_set_up(netif);       }  else  {#ifdef USE_DHCP    /* Update DHCP state machine */    DHCP_state = DHCP_LINK_DOWN;#endif /* USE_DHCP */        /*  When the netif link is down this function must be called.*/    netif_set_down(netif);    #ifdef USE_LCD    BSP_LCD_ClearStringLine(7);    BSP_LCD_ClearStringLine(8);    BSP_LCD_ClearStringLine(9);    BSP_LCD_DisplayStringAtLine(8,(uint8_t *) "  The network cable");    BSP_LCD_DisplayStringAtLine(9,(uint8_t *) "  is not connected");#else    BSP_LED_Off(LED1);    BSP_LED_On(LED2);#endif /* USE_LCD */      }    /* Clear IO Expander Interrupt flag */  BSP_IO_ITClear();}

/**  * @brief  Main routine for Mass Storage Class  * @param  None  * @retval None  */static void MSC_Application(void){  FRESULT res;                                          /* FatFs function common result code */  uint32_t byteswritten, bytesread;                     /* File write/read counts */  uint8_t wtext[] = "This is STM32 working with FatFs"; /* File write buffer */  uint8_t rtext[100];                                   /* File read buffer */    /* Register the file system object to the FatFs module */  if(f_mount(&USBDISKFatFs, (TCHAR const*)USBDISKPath, 0) != FR_OK)  {    /* FatFs Initialization Error */    Error_Handler();  }  else  {    /* Create and Open a new text file object with write access */    if(f_open(&MyFile, "STM32.TXT", FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)     {      /* 'STM32.TXT' file Open for write Error */      Error_Handler();    }    else    {      /* Write data to the text file */      res = f_write(&MyFile, wtext, sizeof(wtext), (void *)&byteswritten);            if((byteswritten == 0) || (res != FR_OK))      {        /* 'STM32.TXT' file Write or EOF Error */        Error_Handler();      }      else      {        /* Close the open text file */        f_close(&MyFile);                /* Open the text file object with read access */        if(f_open(&MyFile, "STM32.TXT", FA_READ) != FR_OK)        {          /* 'STM32.TXT' file Open for read Error */          Error_Handler();        }        else        {          /* Read data from the text file */          res = f_read(&MyFile, rtext, sizeof(rtext), (void *)&bytesread);                    if((bytesread == 0) || (res != FR_OK))          {            /* 'STM32.TXT' file Read or EOF Error */            Error_Handler();          }          else          {            /* Close the open text file */            f_close(&MyFile);                        /* Compare read data with the expected data */            if((bytesread != byteswritten))            {                              /* Read data is different from the expected data */              Error_Handler();            }            else            {              /* Success of the demo: no error occurrence */              BSP_LED_On(LED1);            }          }        }      }    }  }    /* Unlink the USB disk I/O driver */  FATFS_UnLinkDriver(USBDISKPath);}

/**  * @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 LED2, LED2 and LED2 */  BSP_LED_Init(LED2);  /* Configure the system clock to 48 MHz */  SystemClock_Config();  /*##-1- Configure the SPI peripheral #######################################*/  /* Set the SPI parameters */  SpiHandle.Instance               = SPIx;  SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;  SpiHandle.Init.Direction         = SPI_DIRECTION_2LINES;  SpiHandle.Init.CLKPhase          = SPI_PHASE_1EDGE;  SpiHandle.Init.CLKPolarity       = SPI_POLARITY_LOW;  SpiHandle.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;  SpiHandle.Init.CRCPolynomial     = 7;  SpiHandle.Init.DataSize          = SPI_DATASIZE_8BIT;  SpiHandle.Init.FirstBit          = SPI_FIRSTBIT_MSB;  SpiHandle.Init.NSS               = SPI_NSS_SOFT;  SpiHandle.Init.TIMode            = SPI_TIMODE_DISABLE;  SpiHandle.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;  SpiHandle.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;#ifdef MASTER_BOARD  SpiHandle.Init.Mode = SPI_MODE_MASTER;#else  SpiHandle.Init.Mode = SPI_MODE_SLAVE;#endif /* MASTER_BOARD */  if(HAL_SPI_Init(&SpiHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }#ifdef MASTER_BOARD  /* Configure push button */  BSP_PB_Init(BUTTON_USER, BUTTON_MODE_GPIO);  /* Wait for Button press before starting the Communication */  while (BSP_PB_GetState(BUTTON_USER) != GPIO_PIN_RESET)  {    BSP_LED_Toggle(LED2);    HAL_Delay(100);  }  BSP_LED_Off(LED2);#endif /* MASTER_BOARD */  /*##-2- Start the Full Duplex Communication process ########################*/    /* While the SPI in TransmitReceive process, user can transmit data through      "aTxBuffer" buffer & receive data through "aRxBuffer" */  /* Timeout is set to 5S */    switch(HAL_SPI_TransmitReceive(&SpiHandle, (uint8_t*)aTxBuffer, (uint8_t *)aRxBuffer, BUFFERSIZE, 5000))  {    case HAL_OK:      /* Communication is completed ___________________________________________ */      /* Compare the sent and received buffers */      if (Buffercmp((uint8_t *)aTxBuffer, (uint8_t *)aRxBuffer, BUFFERSIZE))      {        /* Transfer error in transmission process */        Error_Handler();      }      /* Turn LED2 on: Transfer in transmission/Reception process is correct */      BSP_LED_On(LED2);      break;    case HAL_TIMEOUT:      /* An Error Occur ______________________________________________________ */    case HAL_ERROR:      /* Call Timeout Handler */      Error_Handler();      break;    default:      break;  }  /* Infinite loop */  while (1)  {  }}

/**  * @brief  SPI error callbacks  * @param  hspi: SPI handle  * @note   This example shows a simple way to report transfer error, and you can  *         add your own implementation.  * @retval None  */ void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi){  /* Turn LED5 on: Transfer error in reception/transmission process */  BSP_LED_On(LED5); }

static void BlueNRG_Init(){  int rc;  uint8_t bdaddr[] = {0x12, 0x34, 0x00, 0xE1, 0x80, 0x02};  uint16_t service_handle, dev_name_char_handle, appearance_char_handle;  const char *ble_name = "BlueNRG";  BSP_LED_On(LED3);  HCI_Init();  /* Enable and set EXTI for BlueNRG IRQ */  HAL_NVIC_SetPriority(BLUENRG_IRQ_EXTI_IRQn, 2, 0);  HAL_NVIC_EnableIRQ(BLUENRG_IRQ_EXTI_IRQn);  BlueNRG_RST();  BSP_LED_On(LED4);  rc = aci_hal_write_config_data(CONFIG_DATA_PUBADDR_OFFSET,                                 CONFIG_DATA_PUBADDR_LEN, bdaddr);  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED4);  }  BSP_LED_On(LED5);  rc = aci_gatt_init();  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED5);  }  BSP_LED_On(LED6);  rc = aci_gap_init(1, &service_handle, &dev_name_char_handle,                    &appearance_char_handle);  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED6);  }  BSP_LED_Off(LED3);  rc = aci_gatt_update_char_value(service_handle, dev_name_char_handle,                                  0, strlen(ble_name), (uint8_t *)ble_name);  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED3);  }  BSP_LED_Off(LED4);  rc = aci_gap_set_auth_requirement(MITM_PROTECTION_REQUIRED,                                    OOB_AUTH_DATA_ABSENT,                                    NULL,                                    7,                                    16,                                    USE_FIXED_PIN_FOR_PAIRING,                                    123456,                                    BONDING);  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED4);  }  /* sensors have been initialized in HW_Init() */  BSP_LED_Off(LED5);  rc = Add_Acc_Service();  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED5);  }  BSP_LED_Off(LED6);  rc = Add_Environmental_Sensor_Service();  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED6);  }  /* Init_User_Timer();  Start_User_Timer(); */  BSP_LED_On(LED3);  /* -2 dBm output power */  rc = aci_hal_set_tx_power_level(1, 4);  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED3);  }}

/**  * @brief  DHCP_Process_Handle  * @param  None  * @retval None  */void DHCP_Process(struct netif *netif){  struct ip_addr ipaddr;  struct ip_addr netmask;  struct ip_addr gw;  uint32_t IPaddress = 0;    switch (DHCP_state)  {  case DHCP_START:    {      netif->ip_addr.addr = 0;      netif->netmask.addr = 0;      netif->gw.addr = 0;      IPaddress = 0;      DHCP_state = DHCP_WAIT_ADDRESS;      dhcp_start(netif);#ifdef USE_LCD      LCD_UsrLog ("  State: Looking for DHCP sever .../n");#endif    }    break;  case DHCP_WAIT_ADDRESS:    {      /* Read the new IP address */      IPaddress = netif->ip_addr.addr;            if (IPaddress !=0)       {        DHCP_state = DHCP_ADDRESS_ASSIGNED;	                /* Stop DHCP */        dhcp_stop(netif);#ifdef USE_LCD         uint8_t iptab[4];        uint8_t iptxt[20];          iptab[0] = (uint8_t)(IPaddress >> 24);        iptab[1] = (uint8_t)(IPaddress >> 16);        iptab[2] = (uint8_t)(IPaddress >> 8);        iptab[3] = (uint8_t)(IPaddress);        sprintf((char*)iptxt, "%d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);               LCD_UsrLog ("IP address assigned by a DHCP server: %s/n", iptxt);#else     BSP_LED_On(LED1);   #endif      }      else      {        /* DHCP timeout */        if (netif->dhcp->tries > MAX_DHCP_TRIES)        {          DHCP_state = DHCP_TIMEOUT;          /* Stop DHCP */          dhcp_stop(netif);          /* Static address used */          IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );          IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);          IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);          netif_set_addr(netif, &ipaddr , &netmask, &gw);#ifdef USE_LCD            uint8_t iptxt[20];                    sprintf((char*)iptxt, "%d.%d.%d.%d", IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);          LCD_UsrLog ("DHCP timeout !!/n");          LCD_UsrLog ("Static IP address  : %s/n", iptxt);      #else     BSP_LED_On(LED1);  #endif        }      }    }

/**  * @brief  TxRx Transfer completed callback.  * @param  hspi: SPI handle  * @note   This example shows a simple way to report end of Interrupt TxRx transfer, and   *         you can add your own implementation.   * @retval None  */void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi){  /* Turn LED on: Transfer in transmission/reception process is correct */  BSP_LED_On(LED2);}

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* STM32L0xx HAL library initialization:       - Configure the Flash prefetch, Flash preread and Buffer 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.       - Low Level Initialization     */  HAL_Init();    /*******************************************************************************  *                          Common Configuration Routines                       *  *******************************************************************************/    /* Configure LED2 and Key Button */  BSP_LED_Init(LED2);  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_EXTI);  /* Configure the system clock to 32 Mhz */  SystemClock_Config();         /*##-1- Check if the system has resumed from IWDG reset ####################*/  if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST) != RESET)  {     /* IWDGRST flag set: Turn LED2 on */    BSP_LED_On(LED2);    /* Insert 4s delay */    HAL_Delay(4000);        /* Clear reset flags */    __HAL_RCC_CLEAR_RESET_FLAGS();  }  else  {    /* IWDGRST flag is not set: Turn LED2 off */    BSP_LED_Off(LED2);  }   /*##-2- Get the LSI frequency: TIM21 is used to measure the LSI frequency ###*/  uwLsiFreq = GetLSIFrequency();    /*##-3- Configure & Initialize the IWDG peripheral ######################################*/  /* Set counter reload value to obtain 250ms IWDG TimeOut.     IWDG counter clock Frequency = LsiFreq/32     Counter Reload Value = 250ms/IWDG counter clock period                          = 0.25s / (32/LsiFreq)                          = LsiFreq/(32 * 4)                          = LsiFreq/128 */  IwdgHandle.Instance = IWDG;  IwdgHandle.Init.Prescaler = IWDG_PRESCALER_32;  IwdgHandle.Init.Reload = uwLsiFreq/128;  IwdgHandle.Init.Window = IWDG_WINDOW_DISABLE;  if(HAL_IWDG_Init(&IwdgHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }    /*##-4- Start the IWDG #####################################################*/   if(HAL_IWDG_Start(&IwdgHandle) != HAL_OK)  {    Error_Handler();  }    /* Infinite loop */   while (1)  {    /* Toggle LED2 */    BSP_LED_Toggle(LED2);    /* Insert 240 ms delay */    HAL_Delay(240);    /* Refresh IWDG: reload counter */    if(HAL_IWDG_Refresh(&IwdgHandle) != HAL_OK)    {      /* Refresh Error */      Error_Handler();    }  }}

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* STM32F3xx 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.       - Set NVIC Group Priority to 4       - Low Level Initialization     */  HAL_Init();  /* Configure the system clock to 72 MHz */  SystemClock_Config();  /* Initialize LED5, LED6 and LED4 */  BSP_LED_Init(LED5);  BSP_LED_Init(LED6);  BSP_LED_Init(LED4);    /* Initialize test status */  MemoryProgramStatus = PASSED;    /* Unlock the Flash to enable the flash control register access *************/   HAL_FLASH_Unlock();  /* Unlock the Options Bytes *************************************************/  HAL_FLASH_OB_Unlock();  /* Get pages write protection status ****************************************/  HAL_FLASHEx_OBGetConfig(&OptionsBytesStruct);#ifdef WRITE_PROTECTION_DISABLE  /* Check if desired pages are already write protected ***********************/  if((OptionsBytesStruct.WRPPage & FLASH_PAGE_TO_BE_PROTECTED) != FLASH_PAGE_TO_BE_PROTECTED)  {    /* Restore write protected pages */    OptionsBytesStruct.OptionType   = OPTIONBYTE_WRP;    OptionsBytesStruct.WRPState     = OB_WRPSTATE_DISABLE;    OptionsBytesStruct.WRPPage = FLASH_PAGE_TO_BE_PROTECTED;    if(HAL_FLASHEx_OBProgram(&OptionsBytesStruct) != HAL_OK)    {      /* Error occurred while options bytes programming. **********************/      while (1)      {        BSP_LED_On(LED4);      }    }    /* Generate System Reset to load the new option byte values ***************/    HAL_FLASH_OB_Launch();  }#elif defined WRITE_PROTECTION_ENABLE  /* Check if desired pages are not yet write protected ***********************/  if(((~OptionsBytesStruct.WRPPage) & FLASH_PAGE_TO_BE_PROTECTED )!= FLASH_PAGE_TO_BE_PROTECTED)  {    /* Enable the pages write protection **************************************/    OptionsBytesStruct.OptionType = OPTIONBYTE_WRP;    OptionsBytesStruct.WRPState   = OB_WRPSTATE_ENABLE;    OptionsBytesStruct.WRPPage    = FLASH_PAGE_TO_BE_PROTECTED;    if(HAL_FLASHEx_OBProgram(&OptionsBytesStruct) != HAL_OK)    {      /* Error occurred while options bytes programming. **********************/      while (1)      {        BSP_LED_On(LED4);      }    }    /* Generate System Reset to load the new option byte values ***************/    HAL_FLASH_OB_Launch();  }#endif /* WRITE_PROTECTION_DISABLE */  /* Lock the Options Bytes *************************************************/  HAL_FLASH_OB_Lock();  /* The selected pages are not write protected *******************************/  if ((OptionsBytesStruct.WRPPage & FLASH_PAGE_TO_BE_PROTECTED) != 0x00)  {    /* Fill EraseInit structure************************************************/    EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;    EraseInitStruct.PageAddress = FLASH_USER_START_ADDR;    EraseInitStruct.NbPages     = (FLASH_USER_END_ADDR - FLASH_USER_START_ADDR)/FLASH_PAGE_SIZE;    if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK)    {      /*         Error occurred while page erase.         User can add here some code to deal with this error.         PageError will contain the faulty page and then to know the code error on this page,        user can call function 'HAL_FLASH_GetError()'      *///.........这里部分代码省略.........

/**  * @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 */  BSP_LED_Init(LED3);  /* Configure the system clock to 48 MHz */  SystemClock_Config();#ifdef BOARD_IN_STOP_MODE    /* HSI must be UART clock source to be able to wake up the MCU */  USARTx_RCC_CONFIG(RCC_USARTxCLKSOURCE_HSI);#endif    /*##-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;  HAL_UART_DeInit(&UartHandle);   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_Init(&UartHandle) != HAL_OK)  {    Error_Handler();  }  #ifdef BOARD_IN_STOP_MODE      BSP_LED_On(LED3);    /* wait for two seconds before test start */    HAL_Delay(2000);     /* make sure that no UART transfer is on-going */    while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET);   /* make sure that UART is ready to receive   * (test carried out again later in HAL_UARTEx_StopModeWakeUpSourceConfig) */      while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET);  /* set the wake-up event:   * specify wake-up on RXNE flag */  WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;  if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)  {    Error_Handler();   }   /* Enable the UART Wake UP from stop mode Interrupt */  __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);    /* about to enter stop mode: switch off LED */  BSP_LED_Off(LED3);  /* enable MCU wake-up by UART */  HAL_UARTEx_EnableStopMode(&UartHandle);   /* enter stop mode */  HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);  /* ... STOP mode ... */        SystemClock_Config_fromSTOP();  /* at that point, MCU has been awoken: the LED has been turned back on */  /* Wake Up based on RXNE flag successful */   HAL_UARTEx_DisableStopMode(&UartHandle);  /* wait for some delay */  HAL_Delay(100);  /* Inform other board that wake up is successful */  if (HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxBuffer1, COUNTOF(aTxBuffer1)-1, 5000)!= HAL_OK)  //.........这里部分代码省略.........

//.........这里部分代码省略.........  /* Configure LED1 and LED3 */  BSP_LED_Init(LED1);  BSP_LED_Init(LED3);   /* Configure the system clock to 48 MHz */  SystemClock_Config();    /*##-1- Link the micro SD disk I/O driver ##################################*/  if(FATFS_LinkDriver(&SD_Driver, SDPath) == 0)  {    /*##-2- Register the file system object to the FatFs module ##############*/    if(f_mount(&SDFatFs, (TCHAR const*)SDPath, 0) != FR_OK)    {      /* FatFs Initialization Error */      Error_Handler();    }    else    {      /*##-3- Create a FAT file system (format) on the logical drive #########*/      /* WARNING: Formatting the uSD card will delete all content on the device */      if(f_mkfs((TCHAR const*)SDPath, 0, 0) != FR_OK)      {        /* FatFs Format Error */        Error_Handler();      }      else      {               /*##-4- Create and Open a new text file object with write access #####*/        if(f_open(&MyFile, "STM32.TXT", FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)        {          /* 'STM32.TXT' file Open for write Error */          Error_Handler();        }        else        {          /*##-5- Write data to the text file ################################*/          res = f_write(&MyFile, wtext, sizeof(wtext), (void *)&byteswritten);          /*##-6- Close the open text file #################################*/          if (f_close(&MyFile) != FR_OK )          {            Error_Handler();          }                    if((byteswritten == 0) || (res != FR_OK))          {            /* 'STM32.TXT' file Write or EOF Error */            Error_Handler();          }          else          {                  /*##-7- Open the text file object with read access ###############*/            if(f_open(&MyFile, "STM32.TXT", FA_READ) != FR_OK)            {              /* 'STM32.TXT' file Open for read Error */              Error_Handler();            }            else            {              /*##-8- Read data from the text file ###########################*/              res = f_read(&MyFile, rtext, sizeof(rtext), (UINT*)&bytesread);                            if((bytesread == 0) || (res != FR_OK))              {                /* 'STM32.TXT' file Read or EOF Error */                Error_Handler();              }              else              {                /*##-9- Close the open text file #############################*/                f_close(&MyFile);                                /*##-10- Compare read data with the expected data ############*/                if((bytesread != byteswritten))                {                                  /* Read data is different from the expected data */                  Error_Handler();                }                else                {                  /* Success of the demo: no error occurrence */                  BSP_LED_On(LED1);                }              }            }          }        }      }    }  }    /*##-11- Unlink the RAM disk I/O driver ####################################*/  FATFS_UnLinkDriver(SDPath);    /* Infinite loop */  while (1)  {  }}

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* Enable the CPU Cache */  CPU_CACHE_Enable();	  /* STM32F7xx HAL library initialization:       - Configure the Flash ART accelerator on ITCM interface       - 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     */  HAL_Init();  /* Configure the system clock to 216 MHz */  SystemClock_Config();   /* Initialize LED1, LED2, LED4 and LED3 */  BSP_LED_Init(LED1);  BSP_LED_Init(LED2);  BSP_LED_Init(LED4);  BSP_LED_Init(LED3);    /*##-1- Configure the CRYP peripheral ######################################*/  CrypHandle.Instance = CRYP;      /* Set the CRYP parameters */  CrypHandle.Init.DataType = CRYP_DATATYPE_8B;  CrypHandle.Init.KeySize  = CRYP_KEYSIZE_128B;  CrypHandle.Init.pKey     = aAES128Key;    if(HAL_CRYP_Init(&CrypHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();   }    /*##-2- Start the AES encryption in ECB chaining mode with DMA #############*/  if(HAL_CRYP_AESECB_Encrypt_DMA(&CrypHandle, aPlaintext, DATA_SIZE, aEncryptedText) != HAL_OK)  {    /* Processing Error */    Error_Handler();   }    /*  Before starting a new process, 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       process, but application may perform other tasks while transfer operation      is ongoing. */   while (HAL_CRYP_GetState(&CrypHandle) != HAL_CRYP_STATE_READY)  {  }    /*##-3- Check the encrypted text with the expected one #####################*/  if(memcmp(aEncryptedText, aCyphertext, DATA_SIZE) != 0)  {    /* Wrong encryption: Turn LED2 on */    BSP_LED_On(LED2);  }  else  {    /* Right encryption: Turn LED1 on */    BSP_LED_On(LED1);  }    /* Deinitialize Crypto peripheral */  HAL_CRYP_DeInit(&CrypHandle);    /* Set the CRYP parameters */  CrypHandle.Init.DataType = CRYP_DATATYPE_8B;  CrypHandle.Init.KeySize  = CRYP_KEYSIZE_128B;  CrypHandle.Init.pKey     = aAES128Key;    if(HAL_CRYP_Init(&CrypHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();   }    /*##-4- Start the AES decryption in ECB chaining mode with DMA #############*/  if(HAL_CRYP_AESECB_Decrypt_DMA(&CrypHandle, aEncryptedText, DATA_SIZE, aDecryptedText) != HAL_OK)  {    /* Processing Error */    Error_Handler();   }    /*  Before starting a new process, 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       process, but application may perform other tasks while transfer operation      is ongoing. */   while (HAL_CRYP_GetState(&CrypHandle) != HAL_CRYP_STATE_READY)//.........这里部分代码省略.........

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){    /* STM32L0xx HAL library initialization:       - Configure the Flash prefetch, Flash preread and Buffer 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.       - Low Level Initialization     */  HAL_Init();  /* Configure the system clock to have a system clock 2 Mhz */  SystemClock_Config();    /* Initialize LED3 */  BSP_LED_Init(LED3);  /* Unlock the Flash to enable the flash control register access *************/   HAL_FLASH_Unlock();  /* Unlock the Options Bytes *************************************************/  HAL_FLASH_OB_Unlock();  /* Get pages write protection status ****************************************/  HAL_FLASHEx_OBGetConfig(&OptionsBytesStruct);  #ifdef WRITE_PROTECTION_DISABLE  /* Get pages already write protected ****************************************/  ProtectedPages = OptionsBytesStruct.WRPSector | FLASH_SECTORS_TO_BE_PROTECTED;    /* Check if there is write protected pages ********************************/  if(ProtectedPages != 0x0)  {    /* Restore write protected pages */    OptionsBytesStruct.OptionType = OPTIONBYTE_WRP;    OptionsBytesStruct.WRPState = WRPSTATE_DISABLE;    OptionsBytesStruct.WRPSector = ProtectedPages;        if(HAL_FLASHEx_OBProgram(&OptionsBytesStruct) != HAL_OK)    {      /* Error occurred while options bytes programming. **********************/      while (1)      {        BSP_LED_On(LED3);      }    }  }    /* Generate System Reset to load the new option byte values ***************/    HAL_FLASH_OB_Launch();  #elif defined WRITE_PROTECTION_ENABLE  /* Get current write protected pages and the new pages to be protected ******/  ProtectedPages =  OptionsBytesStruct.WRPSector | FLASH_SECTORS_TO_BE_PROTECTED;     /* Check if desired pages are not yet write protected ***********************/  if((OptionsBytesStruct.WRPSector & FLASH_SECTORS_TO_BE_PROTECTED )!= FLASH_SECTORS_TO_BE_PROTECTED)  {    /* Enable the pages write protection **************************************/    OptionsBytesStruct.OptionType = OPTIONBYTE_WRP;    OptionsBytesStruct.WRPState = WRPSTATE_ENABLE;    OptionsBytesStruct.WRPSector = ProtectedPages;        if(HAL_FLASHEx_OBProgram(&OptionsBytesStruct) != HAL_OK)    {      /* Error occurred while options bytes programming. **********************/      while (1)      {        BSP_LED_On(LED3);      }    }      /* Generate System Reset to load the new option byte values ***************/    HAL_FLASH_OB_Launch();  }#endif /* WRITE_PROTECTION_DISABLE */  /* Lock the Options Bytes *************************************************/  HAL_FLASH_OB_Lock();#ifdef FLASH_PAGE_PROGRAM    /* The selected pages are not write protected *******************************/  if ((OptionsBytesStruct.WRPSector & FLASH_SECTORS_TO_BE_PROTECTED) == 0x00)  {    /* Fill EraseInit structure************************************************/    EraseInitStruct.TypeErase = TYPEERASE_PAGEERASE;    EraseInitStruct.Page = FLASH_USER_START_ADDR;    EraseInitStruct.NbPages = (FLASH_USER_END_ADDR - FLASH_USER_START_ADDR)/FLASH_PAGE_SIZE;    if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK)    {       /*         Error occurred while page erase. //.........这里部分代码省略.........

/**  * @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 180 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);    /* Initialize the Push buttons */  /* Wakeup button used for Volume Low */      BSP_PB_Init(BUTTON_WAKEUP, BUTTON_MODE_GPIO);   /* Tamper button used for Volume High */   BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_GPIO);      /* Initialize the LCD */  BSP_LCD_Init();    BSP_LCD_LayerDefaultInit(1, 0xC0130000);    BSP_LCD_SelectLayer(1);    /* Display message on EVAL LCD **********************************************/  /* Clear the LCD */   BSP_LCD_Clear(LCD_COLOR_BLUE);      /* Set the LCD Back Color */  BSP_LCD_SetBackColor(LCD_COLOR_BLUE);    /* Set the LCD Text Color */  BSP_LCD_SetTextColor(LCD_COLOR_WHITE);  BSP_LCD_DisplayStringAt(0, LINE(0), (uint8_t *)MESSAGE1, CENTER_MODE);  BSP_LCD_DisplayStringAt(0, LINE(1), (uint8_t *)MESSAGE2, CENTER_MODE);  BSP_LCD_DisplayStringAt(0, LINE(2), (uint8_t *)MESSAGE3, CENTER_MODE);    /* Turn on LEDs available on EVAL *******************************************/  BSP_LED_On(LED1);  BSP_LED_On(LED2);  BSP_LED_On(LED3);  BSP_LED_On(LED4);    /* Initialize the Audio codec and all related peripherals (SAI, I2C, IOs...) */    if(AUDIO_Init() == AUDIO_ERROR_NONE)  {    BSP_LCD_DisplayStringAt(0, LINE(4), (uint8_t *)"====================", CENTER_MODE);    BSP_LCD_DisplayStringAt(0, LINE(5), (uint8_t *)"Tamper: Vol+        ", CENTER_MODE);    BSP_LCD_DisplayStringAt(0, LINE(6), (uint8_t *)"Wakeup: Vol-        ", CENTER_MODE);    BSP_LCD_DisplayStringAt(0, LINE(7), (uint8_t *)"====================", CENTER_MODE);    BSP_LCD_DisplayStringAt(0, LINE(8), (uint8_t *)"  AUDIO CODEC   OK  ", CENTER_MODE);      }  else  {    BSP_LCD_DisplayStringAt(0, LINE(4), (uint8_t *)"  AUDIO CODEC  FAIL ", CENTER_MODE);    BSP_LCD_DisplayStringAt(0, LINE(5), (uint8_t *)" Try to reset board ", CENTER_MODE);  }    /*   Start playing the file from a circular buffer, once the DMA is enabled, it is   always in running state. Application has to fill the buffer with the audio data   using Transfer complete and/or half transfer complete interrupts callbacks   (EVAL_AUDIO_TransferComplete_CallBack() or EVAL_AUDIO_HalfTransfer_CallBack()...  */  AUDIO_Start();    /* Display the state on the screen */  BSP_LCD_DisplayStringAt(0, LINE(9), (uint8_t *)"       PLAYING...     ", CENTER_MODE);     /* IMPORTANT:     AUDIO_Process() is called by the SysTick Handler, as it should be called      within a periodic process */     /* Infinite loop */  while(1)  {          /* Check on the Volume high button */    if (BSP_PB_GetState(BUTTON_WAKEUP) != RESET)    {      /* Wait to avoid rebound */      while (BSP_PB_GetState(BUTTON_WAKEUP) != RESET);            /* Decrease volume by 5% */      if (uwVolume > 5)        uwVolume -= 5;       else//.........这里部分代码省略.........

//.........这里部分代码省略.........  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    /* The board sends the message and expects to receive it back */  /* DMA is programmed for reception before starting the transmission, in order to     be sure DMA Rx is ready when board 2 will start transmitting */  /*##-2- Program the Reception process #####################################*/    if(HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)  {    Error_Handler();  }  /*##-3- Start the transmission process #####################################*/    /* While the UART in reception process, user can transmit data through      "aTxBuffer" buffer */  if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)  {    Error_Handler();  }    /*##-4- Wait for the end of the transfer ###################################*/    while (UartReady != SET)  {  }  /* Reset transmission flag */  UartReady = RESET;  #else    /* The board receives the message and sends it back */  /*##-2- Put UART peripheral in reception process ###########################*/    if(HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)  {    Error_Handler();  }  /*##-3- Wait for the end of the transfer ###################################*/  /* While waiting for message to come from the other board, LED3 is     blinking according to the following pattern: a double flash every half-second */    while (UartReady != SET)  {      BSP_LED_On(LED3);       HAL_Delay(100);      BSP_LED_Off(LED3);       HAL_Delay(100);      BSP_LED_On(LED3);       HAL_Delay(100);      BSP_LED_Off(LED3);       HAL_Delay(500);   }  /* Reset transmission flag */  UartReady = RESET;  BSP_LED_Off(LED3);     /*##-4- Start the transmission process #####################################*/    /* While the UART in reception process, user can transmit data through      "aTxBuffer" buffer */  if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)  {    Error_Handler();  }  #endif /* TRANSMITTER_BOARD */    /*##-5- Wait for the end of the transfer ###################################*/    while (UartReady != SET)  {  }  /* Reset transmission flag */  UartReady = RESET;  /*##-6- Compare the sent and received buffers ##############################*/  if(Buffercmp((uint8_t*)aTxBuffer,(uint8_t*)aRxBuffer,RXBUFFERSIZE))  {    Error_Handler();  }     /* Turn on LED3 if test passes then enter infinite loop */  BSP_LED_On(LED3);   /* Infinite loop */  while (1)  {  }}

/**  * @brief  UART error callbacks  * @param  UartHandle: UART handle  * @note   This example shows a simple way to report transfer error, and you can  *         add your own implementation.  * @retval None  */void HAL_UART_ErrorCallback(UART_HandleTypeDef *UartHandle){  /* Turn LED3 on: Transfer error in reception/transmission process */  BSP_LED_On(LED3); }

/**  * @brief  I2C error callbacks.  * @param  I2cHandle: I2C handle  * @note   This example shows a simple way to report transfer error, and you can  *         add your own implementation.  * @retval None  */void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *I2cHandle){  /* Turn LED3 on: Transfer error in reception/transmission process */  BSP_LED_On(LED3); }

/**  * @brief  Alarm callback  * @param  hrtc : RTC handle  * @retval None  */void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc){  /* Turn LED1 on: Alarm generation */  BSP_LED_On(LED1);}

/**  * @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 180 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);    /* WAKEUP button (EXTI_Line0) will be used to wakeup the system from STOP mode */  BSP_PB_Init(BUTTON_WAKEUP, BUTTON_MODE_EXTI);    /* Configure Key Button */  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);    /*##-1- Configure the SDRAM device #########################################*/  /* SDRAM device configuration */   BSP_SDRAM_Init();        /*##-2- SDRAM memory write access ##########################################*/    /* Fill the buffer to write */  Fill_Buffer(aTxBuffer, BUFFER_SIZE, 0xA244250F);    /* Write data to the SDRAM memory */  BSP_SDRAM_WriteData(SDRAM_DEVICE_ADDR + WRITE_READ_ADDR, aTxBuffer, BUFFER_SIZE);    /* Wait for TAMPER/KEY to be pushed to enter stop mode */  while(BSP_PB_GetState(BUTTON_TAMPER) != RESET)  {  }    /*##-3- Issue self-refresh command to SDRAM device #########################*/   SDRAMCommandStructure.CommandMode            = FMC_SDRAM_CMD_SELFREFRESH_MODE;  SDRAMCommandStructure.CommandTarget          = FMC_SDRAM_CMD_TARGET_BANK1;  SDRAMCommandStructure.AutoRefreshNumber      = 1;  SDRAMCommandStructure.ModeRegisterDefinition = 0;    if(BSP_SDRAM_Sendcmd(&SDRAMCommandStructure) != HAL_OK)   {    /* Command send Error */    Error_Handler();   }     /*##-4- Enter CPU power stop mode ##########################################*/     /* Put LED4 on to indicate entering to STOP mode */  BSP_LED_On(LED4);                            /* Request to enter STOP mode */  HAL_PWR_EnterSTOPMode(PWR_MAINREGULATOR_ON, PWR_STOPENTRY_WFI);    /*##-5- Wakeup CPU from  power stop mode ###################################*/    /* Configure the system clock after wakeup from STOP: enable HSE, PLL and select        PLL as system clock source (HSE and PLL are disabled in STOP mode) */  SystemClock_Config();    /*##-6- SDRAM memory read back access ######################################*/  SDRAMCommandStructure.CommandMode = FMC_SDRAM_CMD_NORMAL_MODE;    if(BSP_SDRAM_Sendcmd(&SDRAMCommandStructure) != HAL_OK)   {    /* Command send Error */    Error_Handler();   }  /* Read back data from the SDRAM memory */  BSP_SDRAM_ReadData(SDRAM_DEVICE_ADDR + WRITE_READ_ADDR, aRxBuffer, BUFFER_SIZE);   /*##-7- Checking data integrity ############################################*/      uwWriteReadStatus = Buffercmp(aTxBuffer, aRxBuffer, BUFFER_SIZE);  if (uwWriteReadStatus != PASSED)  {    /* KO */    /* Turn on LED2 */    BSP_LED_On(LED2);       }  else  {     /* OK */    /* Turn on LED1 */    BSP_LED_On(LED1);  }  /* Infinite loop */    while (1)//.........这里部分代码省略.........

//.........这里部分代码省略.........#ifdef JOYSTICK    /* Get the Joystick State */    JoyState = BSP_JOY_GetState();    switch (JoyState)    {      case JOY_SEL:#endif        if (AudioRec_State == REC_RESET_STATE)        {          /* Display the state on the screen */          BSP_LCD_SetBackColor(LCD_COLOR_WHITE);          BSP_LCD_SetTextColor(LCD_COLOR_BLUE);          BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 80, (uint8_t *)"       RECORDING...     ", CENTER_MODE);          /* Start Recording */          buffer_ctl.rec_length = 0;          buffer_ctl.wr_state = BUFFER_EMPTY;          buffer_ctl.it_state = TRANSFER_NONE;          BSP_AUDIO_IN_Record((uint16_t*)&buffer_ctl.pdm_buff[0], INTERNAL_BUFF_SIZE);          AudioRec_State = RECORD_ONGOING;        }#ifdef JOYSTICK        break;      default:        break;    }#endif    if (CheckForUserInput() > 0)    {      /* Stop recorder and exit the test (go to next test) */      BSP_AUDIO_IN_Stop();      return;    }  }  /* Stop recorder once buffer_ctl.rec_length < AUDIO_REC_TOTAL_SIZE*/  BSP_AUDIO_IN_Stop();  BSP_LCD_SetBackColor(LCD_COLOR_WHITE);  BSP_LCD_SetTextColor(LCD_COLOR_BLUE);  sprintf((char*)FreqStr, "RECORDING DONE, %d frames, START PLAYBACK", NbRecord_done);  BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 65, (uint8_t *)FreqStr, CENTER_MODE);  NbRecord_done = buffer_ctl.rec_length / (DEFAULT_AUDIO_IN_FREQ * DEFAULT_AUDIO_IN_CHANNEL_NBR * 2);  sprintf((char*)FreqStr, "Elapsed_time: %d frames", NbRecord_done);  BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 45, (uint8_t *)FreqStr, CENTER_MODE);  /* -----------Start Playback -------------- */  /* Initialize audio IN at REC_FREQ*/  if(BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_HEADPHONE, 95, DEFAULT_AUDIO_IN_FREQ/2) == 0)  {    BSP_LCD_SetBackColor(LCD_COLOR_WHITE);    BSP_LCD_SetTextColor(LCD_COLOR_GREEN);    BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)"  AUDIO CODEC   OK  ", CENTER_MODE);  }  else  {    BSP_LCD_SetBackColor(LCD_COLOR_WHITE);    BSP_LCD_SetTextColor(LCD_COLOR_RED);    BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)"  AUDIO CODEC  FAIL ", CENTER_MODE);    BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 80, (uint8_t *)" Try to reset board ", CENTER_MODE);  }  /* Play the recorded buffer*/  if(AUDIO_Play_Start((uint32_t *)AUDIO_REC_START_ADDR, (uint32_t)AUDIO_REC_TOTAL_SIZE) == 0)  {    BSP_LCD_SetBackColor(LCD_COLOR_WHITE);    BSP_LCD_SetTextColor(LCD_COLOR_GREEN);    BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)"  AUDIO PLAYBACK   OK  ", CENTER_MODE);  } else  {    BSP_LCD_SetBackColor(LCD_COLOR_WHITE);    BSP_LCD_SetTextColor(LCD_COLOR_RED);    BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)"  AUDIO PLAYBACK  FAIL ", CENTER_MODE);  }    BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 25, (uint8_t *)"PLAYBACK DONE", CENTER_MODE);  while (1)  {    /* Toggle LED4 */    BSP_LED_Toggle(LED4);    /* Insert 100 ms delay */    HAL_Delay(100);    if (CheckForUserInput() > 0)    {      /* Set LED4 */      BSP_LED_On(LED4);      /* Stop recorder */      BSP_AUDIO_IN_Stop();      /* Stop Player before close Test */      BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);      return;    }  }}

/**  * @brief  Tx Transfer completed callback  * @param  huart: UART handle.  * @note   This example shows a simple way to report end of DMA Tx transfer, and  *         you can add your own implementation.  * @retval None  */void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart){  /* Turn LED1 on: Transfer in transmission process is correct */  BSP_LED_On(LED1);}

/**  * @brief  Main program.  * @param  None  * @retval None  */int main(void){   tsl_user_status_t tsl_status;  /* STM32F3xx 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.       - Set NVIC Group Priority to 4       - Low Level Initialization     */  HAL_Init();  /* Configure LEDs */  BSP_LED_Init(LED1);  BSP_LED_Init(LED2);  BSP_LED_Init(LED4);  BSP_LED_Init(LED3);  /* Configure the system clock to 72 MHz */  SystemClock_Config();  /* Configure the TSC peripheral */  TscHandle.Instance                     = TSCx;  TscHandle.Init.AcquisitionMode         = TSC_ACQ_MODE_NORMAL;  TscHandle.Init.CTPulseHighLength       = TSC_CTPH_2CYCLES;  TscHandle.Init.CTPulseLowLength        = TSC_CTPL_2CYCLES;  TscHandle.Init.IODefaultMode           = TSC_IODEF_OUT_PP_LOW;  TscHandle.Init.MaxCountInterrupt       = DISABLE;  TscHandle.Init.MaxCountValue           = TSC_MCV_8191;  TscHandle.Init.PulseGeneratorPrescaler = TSC_PG_PRESC_DIV64;  TscHandle.Init.SpreadSpectrum          = DISABLE;  TscHandle.Init.SpreadSpectrumDeviation = 127;  TscHandle.Init.SpreadSpectrumPrescaler = TSC_SS_PRESC_DIV1;  TscHandle.Init.SynchroPinPolarity      = TSC_SYNC_POLARITY_FALLING;  /* All channel, shield and sampling IOs must be declared below */  TscHandle.Init.ChannelIOs              = (TSC_GROUP8_IO2 | TSC_GROUP8_IO4);  TscHandle.Init.SamplingIOs             = (TSC_GROUP8_IO1 | TSC_GROUP8_IO1 | TSC_GROUP6_IO1);  TscHandle.Init.ShieldIOs               = TSC_GROUP6_IO2;  if (HAL_TSC_Init(&TscHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }  /* Just to indicate the fw is alive... */  BSP_LED_On(LED1);  BSP_LED_On(LED2);  BSP_LED_On(LED4);  BSP_LED_On(LED3);    /* Configure LCD */#if USE_LCD > 0  BSP_LCD_Init();  BSP_LCD_SetFont(&LCD_DEFAULT_FONT);  BSP_LCD_SetBackColor(LCD_COLOR_WHITE);   BSP_LCD_Clear(LCD_COLOR_WHITE);  BSP_LCD_SetTextColor(LCD_COLOR_DARKBLUE);  BSP_LCD_DisplayStringAt(0, 10, (uint8_t *)"STM32F303xE", CENTER_MODE);  BSP_LCD_DisplayStringAt(0, 35, (uint8_t *)"TouchSensing", CENTER_MODE);  BSP_LCD_DisplayStringAt(0, 55, (uint8_t *)"Example", CENTER_MODE);#endif    BSP_LED_Off(LED1);  BSP_LED_Off(LED2);  BSP_LED_Off(LED4);  BSP_LED_Off(LED3);    /* Initialize the STMTouch driver */  tsl_user_Init();    /* Infinite loop */  while (1)  {    /* Execute STMTouch Driver state machine */    tsl_status = tsl_user_Exec();    if (tsl_status != TSL_USER_STATUS_BUSY)    {      Process_Sensors(tsl_status);    }  }}

/**  * @brief  Rx Transfer completed callback  * @param  huart: UART handle  * @note   This example shows a simple way to report end of DMA Rx transfer, and  *         you can add your own implementation.  * @retval None  */void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){  /* Turn LED2 on: Transfer in reception process is correct */  BSP_LED_On(LED2);}

/**  * @brief  DHCP Process* @param  argument: network interface  * @retval None  */void DHCP_thread(void const * argument){  struct netif *netif = (struct netif *) argument;  struct ip_addr ipaddr;  struct ip_addr netmask;  struct ip_addr gw;  uint32_t IPaddress;    for (;;)  {    switch (DHCP_state)    {    case DHCP_START:      {        netif->ip_addr.addr = 0;        netif->netmask.addr = 0;        netif->gw.addr = 0;        IPaddress = 0;        dhcp_start(netif);        DHCP_state = DHCP_WAIT_ADDRESS;#ifdef USE_LCD        BSP_LCD_ClearStringLine(7);        BSP_LCD_ClearStringLine(8);        BSP_LCD_ClearStringLine(9);        BSP_LCD_DisplayStringAtLine(8,(uint8_t *) "  Looking for");        BSP_LCD_DisplayStringAtLine(9,(uint8_t *) "  DHCP sever ...");#endif      }      break;          case DHCP_WAIT_ADDRESS:      {                /* Read the new IP address */        IPaddress = netif->ip_addr.addr;                if (IPaddress!=0)         {          DHCP_state = DHCP_ADDRESS_ASSIGNED;	                    /* Stop DHCP */          dhcp_stop(netif);          #ifdef USE_LCD         uint8_t iptab[4];        uint8_t iptxt[20];          iptab[0] = (uint8_t)(IPaddress >> 24);        iptab[1] = (uint8_t)(IPaddress >> 16);        iptab[2] = (uint8_t)(IPaddress >> 8);        iptab[3] = (uint8_t)(IPaddress);        sprintf((char*)iptxt, "  %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);                       BSP_LCD_ClearStringLine(7);        BSP_LCD_ClearStringLine(8);        BSP_LCD_ClearStringLine(9);        BSP_LCD_DisplayStringAtLine(7,(uint8_t *) "  IP address assigned");        BSP_LCD_DisplayStringAtLine(8,(uint8_t *) "  by a DHCP server:");        BSP_LCD_DisplayStringAtLine(9,(uint8_t *) iptxt);#else     BSP_LED_On(LED1);   #endif         }        else        {          /* DHCP timeout */          if (netif->dhcp->tries > MAX_DHCP_TRIES)          {            DHCP_state = DHCP_TIMEOUT;                        /* Stop DHCP */            dhcp_stop(netif);                        /* Static address used */            IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );            IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);            IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);            netif_set_addr(netif, &ipaddr , &netmask, &gw);            #ifdef USE_LCD            uint8_t iptxt[20];                    sprintf((char*)iptxt, "  %d.%d.%d.%d", IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);          BSP_LCD_ClearStringLine(7);          BSP_LCD_ClearStringLine(8);          BSP_LCD_ClearStringLine(9);          BSP_LCD_DisplayStringAtLine(7,(uint8_t *) "  DHCP timeout !!");          BSP_LCD_DisplayStringAtLine(8,(uint8_t *) "  Static IP address  :");          BSP_LCD_DisplayStringAtLine(9,(uint8_t *) iptxt);#else     BSP_LED_On(LED1);  #endif          }        }//.........这里部分代码省略.........

/**  * @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 and LED4 and User push-button */    BSP_LED_Init(LED3);    BSP_LED_Init(LED4);    BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);    /* Configure the system clock to 48 MHz */    SystemClock_Config();    /*##-1- Check if the system has resumed from WWDG reset ####################*/    if (__HAL_RCC_GET_FLAG(RCC_FLAG_WWDGRST) != RESET)    {        /* WWDGRST flag set: Turn LED3 on */        BSP_LED_On(LED3);        /* Clear reset flags */        __HAL_RCC_CLEAR_RESET_FLAGS();    }    else    {        /* WWDGRST flag is not set: Turn LED3 off */        BSP_LED_Off(LED3);    }    /*##-2- Configure the WWDG peripheral ######################################*/    /* WWDG clock counter = (PCLK1 (48MHz)/4096)/8) = 1464.8 Hz (~683 us)       WWDG Window value = 80 means that the WWDG counter should be refreshed only       when the counter is below 80 (and greater than 64 (63+1)) otherwise a reset will       be generated.       WWDG Counter value = 127, WWDG timeout = ~683 us * 64 = 43.7 ms */    WwdgHandle.Instance = WWDG;    WwdgHandle.Init.Prescaler = WWDG_PRESCALER_8;    WwdgHandle.Init.Window    = 80;    WwdgHandle.Init.Counter   = 127;    if (HAL_WWDG_Init(&WwdgHandle) != HAL_OK)    {        /* Initialization Error */        Error_Handler();    }    /*##-3- Start the WWDG #####################################################*/    if (HAL_WWDG_Start(&WwdgHandle) != HAL_OK)    {        Error_Handler();    }    /* Infinite loop */    while (1)    {        /* Toggle LED4 */        BSP_LED_Toggle(LED4);        /* Insert 40 ms delay */        HAL_Delay(40);        /* Refresh WWDG: update counter value to 127, the refresh window is:        refresh window between 32.1ms (~683 * (127-80)) and 43.7ms (~683 * 64) */        if (HAL_WWDG_Refresh(&WwdgHandle, 127) != HAL_OK)        {            Error_Handler();        }    }}

/**  * @brief  Main program  * @param  None  * @retval None  */int main(void){  /* STM32F4xx HAL library initialization:  - Configure the Flash prefetch and Buffer 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.  - Low Level Initialization  */  HAL_Init();  /* Configure LED3 and LED4 */  BSP_LED_Init(LED3);  BSP_LED_Init(LED4);  /* Configure the system clock to 180 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 Key Button */  BSP_PB_Init(BUTTON_USER, BUTTON_MODE_GPIO);  /* Wait until Key button is pressed to enter the Low Power mode */  while(BSP_PB_GetState(BUTTON_USER) != SET)  {  }  /* Loop while Key button is maintained pressed */  while(BSP_PB_GetState(BUTTON_USER) == SET)  {  }  /* Infinite loop */  while (1)  {#if defined (SLEEP_MODE)    /* Sleep Mode Entry    - System Running at PLL (180MHz)    - Flash 5 wait state    - Instruction and Data caches ON    - Prefetch ON    - Code running from Internal FLASH    - All peripherals disabled.    - Wakeup using EXTI Line (Key Button PC.13)    */    SleepMode_Measure();#elif defined (STOP_MODE)    /* STOP Mode Entry    - RTC Clocked by LSE/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 Wakeup using RTC clocked by LSE/LSI (after ~20s)    */    StopMode_Measure();#elif defined (STANDBY_MODE)    /* STANDBY Mode Entry    - Backup SRAM and RTC OFF    - IWDG and LSI OFF    - Wakeup using WakeUp Pin (PA.00)    */    StandbyMode_Measure();#elif defined (STANDBY_RTC_MODE)    /* STANDBY Mode with RTC on LSE/LSI Entry    - RTC Clocked by LSE or LSI    - IWDG OFF and LSI OFF if not used as RTC Clock source    - Backup SRAM OFF    - Automatic Wakeup using RTC clocked by LSE/LSI (after ~20s)    */    StandbyRTCMode_Measure();#elif defined (STANDBY_RTC_BKPSRAM_MODE)    /* STANDBY Mode with RTC on LSE/LSI Entry    - RTC Clocked by LSE/LSI    - Backup SRAM ON    - IWDG OFF    - Automatic Wakeup using RTC clocked by LSE/LSI (after ~20s)    */    StandbyRTCBKPSRAMMode_Measure();#endif  }}

/**  * @brief  Start task  * @param  pvParameters not used  * @retval None  */static void StartThread(void const *argument){  FRESULT res;                                          /* FatFs function common result code */  uint32_t byteswritten, bytesread;                     /* File write/read counts */  uint8_t wtext[] = "This is STM32 working with FatFs"; /* File write buffer */  uint8_t rtext[100];                                   /* File read buffer */  /*##-1- Link the RAM disk I/O driver #######################################*/  if(FATFS_LinkDriver(&SDRAMDISK_Driver, RAMDISKPath) == 0)  {    /*##-2- Register the file system object to the FatFs module ##############*/    if(f_mount(&RAMDISKFatFs, (TCHAR const*)RAMDISKPath, 0) != FR_OK)    {      /* FatFs Initialization Error */      Error_Handler();    }    else    {      /*##-3- Create a FAT file system (format) on the logical drive #########*/      if(f_mkfs((TCHAR const*)RAMDISKPath, 0, 0) != FR_OK)      {        /* FatFs Format Error */        Error_Handler();      }      else      {        /*##-4- Create and Open a new text file object with write access #####*/        if(f_open(&MyFile, "STM32.TXT", FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)        {          /* 'STM32.TXT' file Open for write Error */          Error_Handler();        }        else        {          /*##-5- Write data to the text file ################################*/          res = f_write(&MyFile, wtext, sizeof(wtext), (void *)&byteswritten);          if((byteswritten == 0) || (res != FR_OK))          {            /* 'STM32.TXT' file Write or EOF Error */            Error_Handler();          }          else          {            /*##-6- Close the open text file #################################*/            f_close(&MyFile);            /*##-7- Open the text file object with read access ###############*/            if(f_open(&MyFile, "STM32.TXT", FA_READ) != FR_OK)            {              /* 'STM32.TXT' file Open for read Error */              Error_Handler();            }            else            {              /*##-8- Read data from the text file ###########################*/              res = f_read(&MyFile, rtext, sizeof(rtext), (void *)&bytesread);              if((bytesread == 0) || (res != FR_OK))              {                /* 'STM32.TXT' file Read or EOF Error */                Error_Handler();              }              else              {                /*##-9- Close the open text file #############################*/                f_close(&MyFile);                /*##-10- Compare read data with the expected data ############*/                if((bytesread != byteswritten))                {                  /* Read data is different from the expected data */                  Error_Handler();                }                else                {                  /* Success of the demo: no error occurrence */                  BSP_LED_On(LED1);                }              }            }          }        }      }    }  }  /*##-11- Unlink the RAM disk I/O driver ####################################*/  FATFS_UnLinkDriver(RAMDISKPath);  /* Infinite Loop */  for( ;; )  {  }}

/**  * @brief  Conversion complete callback in non blocking mode  * @param  hadc : hadc handle  * @note   This example shows a simple way to report end of conversion, and  *         you can add your own implementation.  * @retval None  */void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc){  /* Turn LED1 on: Transfer process is correct */  BSP_LED_On(LED1);}

/**  * @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 and LED3 */  BSP_LED_Init(LED1);  BSP_LED_Init(LED2);  BSP_LED_Init(LED3);  /* Unlock the Flash to enable the flash control register access *************/   HAL_FLASH_Unlock();      /* Erase the user Flash area    (area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/  /* Get the 1st sector to erase */  FirstSector = GetSector(FLASH_USER_START_ADDR);  /* Get the number of sector to erase from 1st sector*/  NbOfSectors = GetSector(FLASH_USER_END_ADDR) - FirstSector + 1;  /* Fill EraseInit structure*/  EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS;  EraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_3;  EraseInitStruct.Sector = FirstSector;  EraseInitStruct.NbSectors = NbOfSectors;    /* Note: If an erase operation in Flash memory also concerns data in the data or instruction cache,     you have to make sure that these data are rewritten before they are accessed during code     execution. If this cannot be done safely, it is recommended to flush the caches by setting the     DCRST and ICRST bits in the FLASH_CR register. */  if(HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) != HAL_OK)  {     /*       Error occurred while sector erase.       User can add here some code to deal with this error.       SectorError will contain the faulty sector and then to know the code error on this sector,      user can call function 'HAL_FLASH_GetError()'    */    while (1)    {      BSP_LED_On(LED3);    }  }  /* Program the user Flash area word by word    (area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/  Address = FLASH_USER_START_ADDR;  while (Address < FLASH_USER_END_ADDR)  {    if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, DATA_32) == HAL_OK)    {      Address = Address + 4;    }    else    {       /* Error occurred while writing data in Flash memory.          User can add here some code to deal with this error */      while (1)      {        BSP_LED_On(LED3);      }    }  }  /* Lock the Flash to disable the flash control register access (recommended     to protect the FLASH memory against possible unwanted operation) *********/  HAL_FLASH_Lock();   /* Check if the programmed data is OK       MemoryProgramStatus = 0: data programmed correctly      MemoryProgramStatus != 0: number of words not programmed correctly ******/  Address = FLASH_USER_START_ADDR;  MemoryProgramStatus = 0;    while (Address < FLASH_USER_END_ADDR)  {    data32 = *(__IO uint32_t*)Address;    if (data32 != DATA_32)    {      MemoryProgramStatus++;      }    Address = Address + 4;//.........这里部分代码省略.........