/**
* @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);
}
else
{
/* Right encryption: Turn LED1 on */
BSP_LED_On(LED1);
}
/* Infinite loop */
while(1)
{
}
}
/**
* @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()'
*/
while (1)
{
BSP_LED_On(LED4);
}
}
/* FLASH Word program of DATA_32 at addresses 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(LED4);
}
}
}
/* Check the correctness of written data */
Address = FLASH_USER_START_ADDR;
while (Address < FLASH_USER_END_ADDR)
{
if((*(__IO uint32_t*) Address) != DATA_32)
{
MemoryProgramStatus = FAILED;
}
Address += 4;
}
}
else
{
/* The desired pages are write protected */
/* Check that it is not allowed to write in this page */
Address = FLASH_USER_START_ADDR;
if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, DATA_32) != HAL_OK)
{
/* Error returned during programmation. */
/* Check that WRPERR flag is well set */
if (HAL_FLASH_GetError() == HAL_FLASH_ERROR_WRP)
{
MemoryProgramStatus = FAILED;
}
else
{
/* Another error occurred.
User can add here some code to deal with this error */
while (1)
{
BSP_LED_On(LED4);
}
}
}
else
{
/* Write operation is successful. Should not occur
User can add here some code to deal with this error */
while (1)
{
BSP_LED_On(LED4);
}
}
}
/* 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 there is an issue to program data*/
if (MemoryProgramStatus == PASSED)
{
/* No error detected. Switch on LED5*/
BSP_LED_On(LED5);
}
else
{
/* Error detected. Switch on LED6*/
BSP_LED_On(LED6);
}
/* Infinite loop */
while (1)
{
}
}
/**
* @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)
{
Error_Handler();
}
/*##-2- Wake Up second step ###############################################*/
/* 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 start-bit detection */
WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
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 on start bit detection 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*)aTxBuffer2, COUNTOF(aTxBuffer2)-1, 5000)!= HAL_OK)
{
Error_Handler();
}
/*##-3- Wake Up third step ################################################*/
/* 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 address-to-match type.
* The address is 0x29, meaning the character triggering the
* address match is 0xA9 */
WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_ADDRESS;
WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
WakeUpSelection.Address = 0x29;
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 on 7-bit address detection 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*)aTxBuffer3, COUNTOF(aTxBuffer3)-1, 5000)!= HAL_OK)
{
Error_Handler();
}
/*##-4- Wake Up fourth step ###############################################*/
/* 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 address-to-match type.
* The address is 0x2, meaning the character triggering the
* address match is 0x82 */
WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_ADDRESS;
WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_4B;
WakeUpSelection.Address = 0x2;
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 on 4-bit address detection successful */
/* wait for some delay */
HAL_Delay(100);
/* Inform other board that wake up is successful */
if (HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxBuffer4, COUNTOF(aTxBuffer4)-1, 5000)!= HAL_OK)
{
Error_Handler();
}
#else
/* initialize the User push-button in Interrupt mode */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
/* Wait for User push-button press before starting the test.
In the meantime, LED3 is blinking */
while(UserButtonStatus == 0)
{
/* Toggle LED3 */
BSP_LED_Toggle(LED3);
HAL_Delay(100);
}
/*##-2- Send the wake-up from stop mode first trigger ######################*/
/* (RXNE flag setting) */
BSP_LED_On(LED3);
if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aWakeUpTrigger1, COUNTOF(aWakeUpTrigger1)-1, 5000)!= HAL_OK)
{
Error_Handler();
}
/* Put UART peripheral in reception process to wait for other board
wake up confirmation */
if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, COUNTOF(aTxBuffer1)-1, 10000) != HAL_OK)
{
Error_Handler();
}
BSP_LED_Off(LED3);
/* Compare the expected and received buffers */
if(Buffercmp((uint8_t*)aTxBuffer1,(uint8_t*)aRxBuffer,COUNTOF(aTxBuffer1)-1))
{
Error_Handler();
}
/* wait for two seconds before test second step */
HAL_Delay(2000);
/*##-3- Send the wake-up from stop mode second trigger #####################*/
/* (start Bit detection) */
BSP_LED_On(LED3);
if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aWakeUpTrigger2, COUNTOF(aWakeUpTrigger2)-1, 5000)!= HAL_OK)
{
Error_Handler();
}
/* Put UART peripheral in reception process to wait for other board
wake up confirmation */
if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, COUNTOF(aTxBuffer2)-1, 10000) != HAL_OK)
{
Error_Handler();
}
BSP_LED_Off(LED3);
/* Compare the expected and received buffers */
if(Buffercmp((uint8_t*)aTxBuffer2,(uint8_t*)aRxBuffer,COUNTOF(aTxBuffer2)-1))
{
Error_Handler();
}
/* wait for two seconds before test third step */
HAL_Delay(2000);
/*##-4- Send the wake-up from stop mode third trigger ######################*/
/* (7-bit address match) */
BSP_LED_On(LED3);
if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aWakeUpTrigger3, 1, 5000)!= HAL_OK)
{
Error_Handler();
}
/* Put UART peripheral in reception process to wait for other board
wake up confirmation */
if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, COUNTOF(aTxBuffer3)-1, 10000) != HAL_OK)
{
Error_Handler();
}
BSP_LED_Off(LED3);
/* Compare the expected and received buffers */
if(Buffercmp((uint8_t*)aTxBuffer3,(uint8_t*)aRxBuffer,COUNTOF(aTxBuffer3)-1))
{
Error_Handler();
}
/* wait for two seconds before test fourth and last step */
HAL_Delay(2000);
/*##-5- Send the wake-up from stop mode fourth trigger #####################*/
/* (4-bit address match) */
BSP_LED_On(LED3);
if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aWakeUpTrigger4, 1, 5000)!= HAL_OK)
{
Error_Handler();
}
/* Put UART peripheral in reception process to wait for other board
wake up confirmation */
if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, COUNTOF(aTxBuffer4)-1, 10000) != HAL_OK)
{
Error_Handler();
}
BSP_LED_Off(LED3);
/* Compare the expected and received buffers */
if(Buffercmp((uint8_t*)aTxBuffer4,(uint8_t*)aRxBuffer,COUNTOF(aTxBuffer4)-1))
{
Error_Handler();
}
HAL_Delay(2000);
#endif /* BOARD_IN_STOP_MODE */
/* Turn on LED3 if test passes then enter infinite loop */
BSP_LED_On(LED3);
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(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 */
/* 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 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)
{
}
/*##-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);
}
else
{
/* Right encryption: Turn LED4 on */
BSP_LED_On(LED4);
}
/* Infinite loop */
while(1)
{
}
}
/**
* @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.
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()'
*/
while (1)
{
BSP_LED_On(LED3);
}
}
/* FLASH Word program of data 0x35711753 at addresses 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(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);
}
}
}
/* Check the correctness of written data */
Address = FLASH_USER_START_ADDR;
MemoryProgramStatus = 0;
while (Address < FLASH_USER_END_ADDR)
{
if((*(__IO uint32_t*) Address) != DATA_32)
{
MemoryProgramStatus = 1;
}
Address += 4;
}
}
else
{
/* Error to program the flash : The desired pages are write protected */
MemoryProgramStatus = 1;
}
#endif /* FLASH_PAGE_PROGRAM */
/* 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 there is an issue to program data*/
if (MemoryProgramStatus != 0)
{
/* Error detected. Switch on LED3*/
BSP_LED_On(LED3);
}
/* Infinite loop */
while (1)
{
}
}
/**
* @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
uwVolume = 0;
/* Apply the new volume to the codec */
BSP_AUDIO_OUT_SetVolume(uwVolume);
BSP_LCD_DisplayStringAt(0, LINE(10), (uint8_t *)" VOL: - ", CENTER_MODE);
}
/* Check on the Volume high button */
if (BSP_PB_GetState(BUTTON_TAMPER) == RESET)
{
/* Wait to avoid rebound */
while (BSP_PB_GetState(BUTTON_TAMPER) == RESET);
/* Increase volume by 5% */
if (uwVolume < 95)
uwVolume += 5;
else
uwVolume = 100;
/* Apply the new volume to the codec */
BSP_AUDIO_OUT_SetVolume(uwVolume);
BSP_LCD_DisplayStringAt(0, LINE(10), (uint8_t *)" VOL: + ", CENTER_MODE);
}
/* Toggle LED3 */
BSP_LED_Toggle(LED3);
/* Insert 100 ms delay */
HAL_Delay(100);
/* Toggle LED2 */
BSP_LED_Toggle(LED2);
/* Insert 100 ms delay */
HAL_Delay(100);
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
#ifdef TRANSMITTER_BOARD
GPIO_InitTypeDef GPIO_InitStruct;
#endif
/* 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 the system clock to 48 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
#ifdef TRANSMITTER_BOARD
/* Configure PA.12 (Arduino D2) as input with External interrupt */
GPIO_InitStruct.Pin = GPIO_PIN_12;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
/* Enable GPIOA clock */
__HAL_RCC_GPIOA_CLK_ENABLE();
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Enable and set PA.12 (Arduino D2) EXTI Interrupt to the lowest priority */
NVIC_SetPriority((IRQn_Type)(EXTI4_15_IRQn), 0x03);
HAL_NVIC_EnableIRQ((IRQn_Type)(EXTI4_15_IRQn));
/* Wait for the user to set GPIOA to GND before starting the Communication.
In the meantime, LED3 is blinking */
while(VirtualUserButtonStatus == 0)
{
/* Toggle LED3*/
BSP_LED_Toggle(LED3);
HAL_Delay(100);
}
BSP_LED_Off(LED3);
#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;
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
/* 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)
{
}
}
/**
* @brief Audio Play demo
* @param None
* @retval None
*/
void AudioRec_demo (void)
{
uint16_t NbRecord_done = 0;
uint8_t FreqStr[256] = {0};
AudioRec_State = REC_NONE_STATE;
buffer_ctl.rec_length = 0;
/* Initialize AudioRecFullBuff at the address of the audio_play reader */
AudioRecFullBuff_addr = AUDIO_REC_START_ADDR;
AudioRec_SetHint();
#ifdef JOYSTICK
/* Initialize Joystick */
if (BSP_JOY_Init(JOY_MODE_GPIO) != IO_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 *)"Joystick cannot be initialized", CENTER_MODE);
}
#endif
/* Initialize Audio Recorder */
if (BSP_AUDIO_IN_Init(DEFAULT_AUDIO_IN_FREQ, DEFAULT_AUDIO_IN_BIT_RESOLUTION, DEFAULT_AUDIO_IN_CHANNEL_NBR) == AUDIO_OK)
{
AudioRec_State = REC_RESET_STATE;
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)" AUDIO RECORD INIT OK ", CENTER_MODE);
}
else
{
AudioRec_State = REC_ERROR_STATE;
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)" AUDIO RECORD INIT FAIL", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 80, (uint8_t *)" Try to reset board ", CENTER_MODE);
}
/* Infinite loop */
while (buffer_ctl.rec_length < AUDIO_REC_TOTAL_SIZE)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
if (buffer_ctl.it_state == TRANSFER_HALF)
{
/* PDM to PCM data convert */
BSP_AUDIO_IN_PDMToPCM((uint16_t*)&buffer_ctl.pdm_buff[0],
&buffer_ctl.pcm_buff[buffer_ctl.pcm_ptr]);
buffer_ctl.pcm_ptr+= AUDIO_IN_PDM_BUFFER_SIZE/4/2;
if(buffer_ctl.pcm_ptr == AUDIO_IN_PCM_BUFFER_SIZE/2)
{
buffer_ctl.wr_state = BUFFER_FULL;
buffer_ctl.offset = 0;
}
if(buffer_ctl.pcm_ptr >= AUDIO_IN_PCM_BUFFER_SIZE)
{
buffer_ctl.wr_state = BUFFER_FULL;
buffer_ctl.offset = AUDIO_IN_PCM_BUFFER_SIZE/2;
buffer_ctl.pcm_ptr = 0;
}
buffer_ctl.it_state = TRANSFER_NONE;
}
if (buffer_ctl.it_state == TRANSFER_FULL)
{
/* PDM to PCM data convert */
if (BSP_AUDIO_IN_PDMToPCM((uint16_t*)&buffer_ctl.pdm_buff[INTERNAL_BUFF_SIZE/2], &buffer_ctl.pcm_buff[buffer_ctl.pcm_ptr]) == 0)
{
buffer_ctl.pcm_ptr+= AUDIO_IN_PDM_BUFFER_SIZE/4/2;
if(buffer_ctl.pcm_ptr == AUDIO_IN_PCM_BUFFER_SIZE/2)
{
buffer_ctl.wr_state = BUFFER_FULL;
buffer_ctl.offset = 0;
}
if(buffer_ctl.pcm_ptr >= AUDIO_IN_PCM_BUFFER_SIZE)
{
buffer_ctl.wr_state = BUFFER_FULL;
buffer_ctl.offset = AUDIO_IN_PCM_BUFFER_SIZE/2;
buffer_ctl.pcm_ptr = 0;
}
}
buffer_ctl.it_state = TRANSFER_NONE;
NbRecord_done++;
}
/* PCM buffer is full, copy it into the record_file */
if (buffer_ctl.wr_state == BUFFER_FULL)
{
memcpy((uint32_t *)AudioRecFullBuff_addr, (uint8_t*)(buffer_ctl.pcm_buff + buffer_ctl.offset), AUDIO_IN_PCM_BUFFER_SIZE);
AudioRecFullBuff_addr += AUDIO_IN_PCM_BUFFER_SIZE;
buffer_ctl.rec_length += AUDIO_IN_PCM_BUFFER_SIZE;
buffer_ctl.wr_state = BUFFER_EMPTY;
}
#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
}
}
}
break;
default: break;
}
/**
* @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;
}
/* Check if there is an issue to program data */
if (MemoryProgramStatus == 0)
{
/* No error detected. Switch on LED1 */
BSP_LED_On(LED1);
}
else
{
/* Error detected. Switch on LED2 */
BSP_LED_On(LED2);
}
/* Infinite loop */
while (1)
{
}
}