/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure LED3 and LED4 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure the system clock to 168 MHz */
SystemClock_Config();
/*##-1- Configure the I2C peripheral #######################################*/
I2cHandle.Instance = I2Cx;
I2cHandle.Init.AddressingMode = I2C_ADDRESSINGMODE_10BIT;
I2cHandle.Init.ClockSpeed = 400000;
I2cHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
I2cHandle.Init.DutyCycle = I2C_DUTYCYCLE_16_9;
I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
I2cHandle.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
I2cHandle.Init.OwnAddress1 = I2C_ADDRESS;
I2cHandle.Init.OwnAddress2 = 0xFE;
if(HAL_I2C_Init(&I2cHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
#ifdef MASTER_BOARD
/* Configure USER Button */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
/* Wait for USER Button press before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) != 1)
{
}
/* Wait for USER Button release before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) != 0)
{
}
/* The board sends the message and expects to receive it back */
/*##-2- Start the transmission process #####################################*/
/* While the I2C in reception process, user can transmit data through
"aTxBuffer" buffer */
/* Timeout is set to 10S */
while(HAL_I2C_Master_Transmit(&I2cHandle, (uint16_t)I2C_ADDRESS, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 10000)!= HAL_OK)
{
/* Error_Handler() function is called when Timeout error occurs.
When Acknowledge failure occurs (Slave don't acknowledge it's address)
Master restarts communication */
if (HAL_I2C_GetError(&I2cHandle) != HAL_I2C_ERROR_AF)
{
Error_Handler();
}
}
/* Turn LED3 on: Transfer in Transmission process is correct */
BSP_LED_On(LED3);
/* Wait for USER Button press before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) != 1)
{
}
/* Wait for USER Button release before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) != 0)
{
}
/*##-3- Put I2C peripheral in reception process ############################*/
/* Timeout is set to 10S */
while(HAL_I2C_Master_Receive(&I2cHandle, (uint16_t)I2C_ADDRESS, (uint8_t *)aRxBuffer, RXBUFFERSIZE, 10000) != HAL_OK)
{
/* Error_Handler() function is called when Timeout error occurs.
When Acknowledge failure occurs (Slave don't acknowledge it's address)
Master restarts communication */
if (HAL_I2C_GetError(&I2cHandle) != HAL_I2C_ERROR_AF)
{
Error_Handler();
}
}
/* Turn LED3 off: Transfer in reception process is correct */
BSP_LED_Off(LED3);
#else
/* The board receives the message and sends it back */
/*##-2- Put I2C peripheral in reception process ############################*/
/* Timeout is set to 10S */
if(HAL_I2C_Slave_Receive(&I2cHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE, 10000) != HAL_OK)
{
/* Transfer error in reception process */
Error_Handler();
}
/* Turn LED3 on: Transfer in reception process is correct */
BSP_LED_On(LED3);
/*##-3- Start the transmission process #####################################*/
/* While the I2C in reception process, user can transmit data through
"aTxBuffer" buffer */
/* Timeout is set to 10S */
if(HAL_I2C_Slave_Transmit(&I2cHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 10000)!= HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/* Turn LED3 off: Transfer in transmission process is correct */
BSP_LED_Off(LED3);
#endif /* MASTER_BOARD */
/*##-4- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer,(uint8_t*)aRxBuffer,RXBUFFERSIZE))
{
/* Processing Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @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 LED3, LED4 and LED5 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
BSP_LED_Init(LED5);
/* Configure the system clock to 72 MHz */
SystemClock_Config();
/*##-1- Configure the SPI peripheral #######################################*/
/* Set the SPI parameters */
SpiHandle.Instance = SPIx;
SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
SpiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
SpiHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
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_DISABLED;
SpiHandle.Init.NSSPMode = SPI_NSS_PULSE_DISABLED;
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 the 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_SET)
{
}
#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" */
if(HAL_SPI_TransmitReceive_DMA(&SpiHandle, (uint8_t*)aTxBuffer, (uint8_t *)aRxBuffer, BUFFERSIZE) != HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-3- Wait for the end of the transfer ###################################*/
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_SPI_GetState(&SpiHandle) != HAL_SPI_STATE_READY)
{
}
/*##-4- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer, (uint8_t*)aRxBuffer, BUFFERSIZE))
{
/* Processing Error */
Error_Handler();
}
/* 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();
/* Initialize LEDs available on STM324xG-EVAL board *************************/
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure the system clock to 180 Mhz */
SystemClock_Config();
SC_State SCState = SC_POWER_OFF;
/* Configure Smartcard Interface GPIO pins */
SC_IOConfig();
/*-------------------------------- Idle task ---------------------------------*/
while(1)
{
/* Loop while no Smartcard is detected */
while(CardInserted == 0)
{
}
/* Start SC Demo ---------------------------------------------------------*/
/* Wait A2R --------------------------------------------------------------*/
SCState = SC_POWER_ON;
SC_ADPU.Header.CLA = 0x00;
SC_ADPU.Header.INS = SC_GET_A2R;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
while(SCState != SC_ACTIVE_ON_T0)
{
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Apply the Procedure Type Selection (PTS) */
SC_PTSConfig();
/* Inserts delay(400ms) for Smartard clock resynchronisation */
HAL_Delay(400);
/* Select MF -------------------------------------------------------------*/
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = MasterRoot[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
/* Get Response on MF ----------------------------------------------------*/
if(SC_Response.SW1 == SC_DF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_GET_RESPONCE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = SC_Response.SW2;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Select ICCID ----------------------------------------------------------*/
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Check if the CHV1 is enabled */
if((SC_Response.Data[13] & 0x80) == 0x00)
{
CHV1Status = 0x01;
}
/* Send APDU Command for ICCID selection */
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = ICCID[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Read Binary in ICCID --------------------------------------------------*/
if(SC_Response.SW1 == SC_EF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_READ_BINARY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = 10;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Select GSMDir ---------------------------------------------------------*/
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Copy the ICCID File content into ICCID_Content buffer */
for(i = 0; i < SC_ADPU.Body.LE; i++)
{
ICCID_Content[i] = SC_Response.Data[i];
}
/* Send APDU Command for GSMDir selection */
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = GSMDir[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Select IMSI -----------------------------------------------------------*/
if(SC_Response.SW1 == SC_DF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = IMSI[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Get Response on IMSI File ---------------------------------------------*/
if(SC_Response.SW1 == SC_EF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_GET_RESPONCE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = SC_Response.SW2;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Read Binary in IMSI ---------------------------------------------------*/
if(CHV1Status == 0x00)
{
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Enable CHV1 (PIN1) ------------------------------------------------*/
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_ENABLE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x01;
SC_ADPU.Body.LC = 0x08;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = CHV1[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
}
else
{
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Verify CHV1 (PIN1) ------------------------------------------------*/
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_VERIFY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x01;
SC_ADPU.Body.LC = 0x08;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = CHV1[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
}
/* Read Binary in IMSI ---------------------------------------------------*/
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_READ_BINARY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = 9;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Copy the IMSI File content into IMSI_Content buffer */
for(i = 0; i < SC_ADPU.Body.LE; i++)
{
IMSI_Content[i] = SC_Response.Data[i];
}
}
/* Disable the Smartcard interface */
SCState = SC_POWER_OFF;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
CardInserted = 0;
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx 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 LED3 */
BSP_LED_Init(LED3);
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/* Compute the prescaler value to have TIM3 counter clock equal to 36000000 Hz */
uhPrescalerValue = (uint32_t)(SystemCoreClock / 36000000) - 1;
/*##-1- Configure the TIM peripheral #######################################*/
/* -----------------------------------------------------------------------
TIM3 Configuration: generate 1 PWM signal with clock prescaler selection feature activated using __HAL_RCC_TIMCLKPRESCALER()
which allow to double the output frequency.
In this example TIM3 input clock (TIM3CLK) is set to 4 * APB1 clock (PCLK1), since
Timer clock prescalers selection activated (TIMPRE bit from RCC_DCKCFGR register is set).
TIM3CLK = 4 * PCLK1
PCLK1 = HCLK / 4
=> TIM3CLK = HCLK = SystemCoreClock
For TIM3CLK equal to SystemCoreClock and prescaler equal to (5 - 1), TIM3 counter clock
is computed as follows:
TIM3 counter clock = TIM3CLK / (Prescaler + 1)
= SystemCoreClock / (Prescaler + 1)
= 36MHz
For ARR equal to (1800 - 1), the TIM3 output clock is computed as follows:
TIM3 output clock = TIM3 counter clock / (ARR + 1)
= 20KHZ
The TIM3 CCR1 register value is equal to 900, so the TIM3 Channel 1 generates a
PWM signal with a frequency equal to 20 KHz and a duty cycle equal to 50%:
TIM3 Channel1 duty cycle = (TIM3_CCR1/ TIM3_ARR + 1)* 100 = 50%
Note:
SystemCoreClock variable holds HCLK frequency and is defined in system_stm32f4xx.c file.
Each time the core clock (HCLK) changes, user had to update SystemCoreClock
variable value. Otherwise, any configuration based on this variable will be incorrect.
This variable is updated in three ways:
1) by calling CMSIS function SystemCoreClockUpdate()
2) by calling HAL API function HAL_RCC_GetSysClockFreq()
3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency
----------------------------------------------------------------------- */
/* Timer clock prescalers selection activation */
__HAL_RCC_TIMCLKPRESCALER(RCC_TIMPRES_ACTIVATED);
/* Initialize TIMx peripheral as follows:
+ Prescaler = (SystemCoreClock / 36000000) - 1
+ Period = (1800 - 1)
+ ClockDivision = 0
+ Counter direction = Up
*/
TimHandle.Instance = TIMx;
TimHandle.Init.Prescaler = uhPrescalerValue;
TimHandle.Init.Period = PERIOD_VALUE;
TimHandle.Init.ClockDivision = 0;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
TimHandle.Init.RepetitionCounter = 0;
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure the PWM channels #########################################*/
/* Common configuration for all channels */
sConfig.OCMode = TIM_OCMODE_PWM1;
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfig.OCFastMode = TIM_OCFAST_DISABLE;
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
/* Set the pulse value for channel 1 */
sConfig.Pulse = PULSE1_VALUE;
if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*##-3- Start PWM signals generation #######################################*/
/* Start channel 1 */
if (HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1) != HAL_OK)
{
/* PWM Generation Error */
Error_Handler();
}
/* Start channel 2 */
if (HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2) != HAL_OK)
{
/* PWM Generation Error */
Error_Handler();
}
/* Start channel 3 */
if (HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3) != HAL_OK)
{
/* PWM generation Error */
Error_Handler();
}
/* Start channel 4 */
if (HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4) != HAL_OK)
{
/* PWM generation Error */
Error_Handler();
}
while (1)
{
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock to 100 MHz */
SystemClock_Config();
/* Unlock the Flash Program Erase controller */
HAL_FLASH_Unlock();
/* Configure LED2 */
BSP_LED_Init(LED2);
/* EEPROM Init */
if( EE_Init() != EE_OK)
{
Error_Handler();
}
/* --- Store successively many values of the three variables in the EEPROM ---*/
/* Store 0x1000 values of Variable1 in EEPROM */
for (VarValue = 1; VarValue <= 0x1000; VarValue++)
{
/* Sequence 1 */
if((EE_WriteVariable(VirtAddVarTab[0], VarValue)) != HAL_OK)
{
Error_Handler();
}
if((EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0])) != HAL_OK)
{
Error_Handler();
}
if (VarValue != VarDataTab[0])
{
Error_Handler();
}
/* Sequence 2 */
if(EE_WriteVariable(VirtAddVarTab[1], ~VarValue) != HAL_OK)
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[1], &VarDataTab[1]) != HAL_OK)
{
Error_Handler();
}
if(((uint16_t)~VarValue) != VarDataTab[1])
{
Error_Handler();
}
/* Sequence 3 */
if(EE_WriteVariable(VirtAddVarTab[2], VarValue << 1) != HAL_OK)
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[2], &VarDataTab[2]) != HAL_OK)
{
Error_Handler();
}
if ((VarValue << 1) != VarDataTab[2])
{
Error_Handler();
}
}
/* Store 0x2000 values of Variable2 in EEPROM */
for (VarValue = 1; VarValue <= 0x2000; VarValue++)
{
if(EE_WriteVariable(VirtAddVarTab[1], VarValue) != HAL_OK)
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[1], &VarDataTab[1]) != HAL_OK)
{
Error_Handler();
}
if(VarValue != VarDataTab[1])
{
Error_Handler();
}
}
/* read the last stored variables data*/
if(EE_ReadVariable(VirtAddVarTab[0], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[0])
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[1], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[1])
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[2], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[2])
{
Error_Handler();
}
/* Store 0x3000 values of Variable3 in EEPROM */
for (VarValue = 1; VarValue <= 0x3000; VarValue++)
{
if(EE_WriteVariable(VirtAddVarTab[2], VarValue) != HAL_OK)
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[2], &VarDataTab[2]) != HAL_OK)
{
Error_Handler();
}
if(VarValue != VarDataTab[2])
{
Error_Handler();
}
}
/* read the last stored variables data*/
if(EE_ReadVariable(VirtAddVarTab[0], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[0])
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[1], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[1])
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[2], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[2])
{
Error_Handler();
}
while (1)
{
/* Turn LED2 On */
BSP_LED_On(LED2);
}
}
/**
* @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 LED1 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/* Configure the system clock to 72 MHz */
SystemClock_Config();
/*## Configuration of peripherals ##########################################*/
/* Configure the ADCx and ADCy peripherals */
ADC_Config();
/* Run the ADC calibration in single-ended mode */
if (HAL_ADCEx_Calibration_Start(&AdcHandle_master, ADC_SINGLE_ENDED) != HAL_OK)
{
/* Calibration Error */
Error_Handler();
}
if (HAL_ADCEx_Calibration_Start(&AdcHandle_slave, ADC_SINGLE_ENDED) != HAL_OK)
{
/* Calibration Error */
Error_Handler();
}
/*## Enable peripherals ####################################################*/
/* Enable ADC slave */
if (HAL_ADC_Start(&AdcHandle_slave) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/*## Start ADC conversions #################################################*/
/* Start ADCx and ADCy multimode conversion with interruption */
if (HAL_ADCEx_MultiModeStart_DMA(&AdcHandle_master, (uint32_t *)aADCDualConvertedValue, 256) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/* Array "aADCDualConvertedValue" contains both ADC results on 16 bits: */
/* - ADC master results in the 8 LSB [7:0] */
/* - ADC slave results in the 8 MSB [15:8] */
/* Infinite loop */
while (1)
{
if(aADCDualConversionDone == 1)
{
/* Toggle LED1: Conversions results are available */
/* The toggle frequency depends on Conversion Value link to RV2 position */
/* In the case of this example: */
/* HAL_ADC_ConvCpltCallback() is called when DMA Transfer process is */
/* completed. */
/* Since ADC and DMA are configured in continuous and circular mode, this */
/* function will be called each time the DMA buffer length is reached. */
BSP_LED_Toggle(LED1);
HAL_Delay(aADCDualConversionValue*10);
aADCDualConversionDone = 0;
}
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
ADC_ChannelConfTypeDef sConfig;
/* 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 have a system clock = 144 Mhz */
SystemClock_Config();
/* Configure LED1 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/*##-1- Configure the ADC peripheral #######################################*/
AdcHandle.Instance = ADCx;
AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
AdcHandle.Init.Resolution = ADC_RESOLUTION12b;
AdcHandle.Init.ScanConvMode = DISABLE;
AdcHandle.Init.ContinuousConvMode = ENABLE;
AdcHandle.Init.DiscontinuousConvMode = DISABLE;
AdcHandle.Init.NbrOfDiscConversion = 0;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.NbrOfConversion = 1;
AdcHandle.Init.DMAContinuousRequests = ENABLE;
AdcHandle.Init.EOCSelection = DISABLE;
if(HAL_ADC_Init(&AdcHandle) != HAL_OK)
{
/* Initiliazation Error */
Error_Handler();
}
/*##-2- Configure ADC regular channel ######################################*/
sConfig.Channel = ADCx_CHANNEL;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
sConfig.Offset = 0;
if(HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
/*##-3- Start the conversion process and enable interrupt ##################*/
if(HAL_ADC_Start_DMA(&AdcHandle, (uint32_t*)&uhADCxConvertedValue, 1) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/* 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 168 MHz */
SystemClock_Config();
/* Configure LED1 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/*##-1- Init Host Library ##################################################*/
USBH_Init(&hUSB_Host, USBH_UserProcess, 0);
/* Add Supported Class */
USBH_RegisterClass(&hUSB_Host, USBH_MSC_CLASS);
/* Start Host Process */
USBH_Start(&hUSB_Host);
/*##-2- Disable SAI1_SDA signal ############################################*/
/* Note: In STM324x9I-EVAL RevB, PE6 pin is shared between data_7 of camera
and SAI1_SDA of codec WM8994, after power on, SAI1_SDA pin of codec WM8994
is in output state, thus preventing MCU from receiving correct signal
from camera, so we need to configure SAI1_SDA pin of codec WM8994
in tri-state */
/* Initialize the Control interface of the Audio Codec */
BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_SPEAKER, 70, AUDIO_FREQUENCY_48K);
/* ADCDAT1 is tri-stated */
AUDIO_IO_Write(AUDIO_I2C_ADDRESS, 0x200, 0);
AUDIO_IO_Write(AUDIO_I2C_ADDRESS, 0x300, 0x6010);
/*##-3- Configure TAMPER Button ############################################*/
BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_GPIO);
/*##-4- Link the USB Host disk I/O driver ##################################*/
FATFS_LinkDriver(&USBH_Driver, MSC_Path);
/*##-5- Initialize the LCD #################################################*/
BSP_LCD_Init();
/* Foreground Layer Initialization */
BSP_LCD_LayerDefaultInit(1, LCD_FRAME_BUFFER_LAYER1);
/* Set Foreground Layer */
BSP_LCD_SelectLayer(1);
/* Clear the LCD Foreground layer */
BSP_LCD_Clear(LCD_COLOR_WHITE);
BSP_LCD_SetLayerVisible(1, DISABLE);
/* Background Layer Initialization */
BSP_LCD_LayerDefaultInit(0, LCD_FRAME_BUFFER);
/* Enable the LCD */
BSP_LCD_DisplayOn();
/* Select the LCD Foreground layer */
BSP_LCD_SelectLayer(0);
BSP_LCD_Clear(LCD_COLOR_WHITE);
/*##-6- Camera Initialization and start capture ############################*/
/* Initialize the Camera */
BSP_CAMERA_Init(RESOLUTION_R480x272);
/* Start the Camera Capture */
BSP_CAMERA_ContinuousStart((uint8_t *)CAMERA_FRAME_BUFFER);
/*##-7- Run Application ####################################################*/
while (1)
{
/* USB Host Background task */
USBH_Process(&hUSB_Host);
switch(Appli_state)
{
case STORAGE_READY:
CAMERA_Capture();
break;
case STORAGE_IDLE:
break;
}
}
}
/**
* @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();
/* Configure LED3 */
BSP_LED_Init(LED3);
/* Timers configuration ------------------------------------------------------
1/TIM2 is configured as Master Timer:
- PWM Mode is used
- The TIM2 Update event is used as Trigger Output
2/TIM3 is slave for TIM2 and Master for TIM4,
- PWM Mode is used
- The ITR1(TIM2) is used as input trigger
- Gated mode is used, so start and stop of slave counter
are controlled by the Master trigger output signal(TIM2 update event).
- The TIM3 Update event is used as Trigger Output.
3/TIM4 is slave for TIM3,
- PWM Mode is used
- The ITR2(TIM3) is used as input trigger
- Gated mode is used, so start and stop of slave counter
are controlled by the Master trigger output signal(TIM3 update event).
In this example TIM2 input clock (TIM2CLK) is set to 2 * APB1 clock (PCLK1),
since APB1 prescaler is different from 1.
TIM2CLK = 2 * PCLK1
PCLK1 = HCLK / 4
=> TIM2CLK = HCLK / 2 = SystemCoreClock /2
The TIM2 counter clock is equal to SystemCoreClock/2 = 216 MHz/2.
The Master Timer TIM2 is running at:
TIM2 frequency = TIM2 counter clock / (TIM2_Period + 1) = 390.625 KHz
TIM2_Period = (TIM2 counter clock / TIM2 frequency) - 1 = 182
and the duty cycle is equal to: TIM2_CCR1/(TIM2_ARR + 1) = 25%
The TIM3 is running:
- At (TIM2 frequency)/ (TIM3 period + 1) = 97.656 KHz and a duty cycle
equal to TIM3_CCR1/(TIM3_ARR + 1) = 25%
The TIM4 is running:
- At (TIM3 frequency)/ (TIM4 period + 1) = 24.414 KHz and a duty cycle
equal to TIM4_CCR1/(TIM4_ARR + 1) = 25%
Note:
SystemCoreClock variable holds HCLK frequency and is defined in SystemClock_Config().
Each time the core clock (HCLK) changes, user had to update SystemCoreClock
variable value. Otherwise, any configuration based on this variable will be incorrect.
This variable is updated in three ways:
1) by calling CMSIS function SystemCoreClockUpdate()
2) by calling HAL API function HAL_RCC_GetSysClockFreq()
3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency
--------------------------------------------------------------------------- */
/* Set Timers instance */
TimMasterHandle.Instance = TIM2;
TimSlave1Handle.Instance = TIM3;
TimSlave2Handle.Instance = TIM4;
/*====================== Master configuration : TIM2 =======================*/
/* Initialize TIM2 peripheral in PWM mode*/
TimMasterHandle.Init.Period = 255;
TimMasterHandle.Init.Prescaler = 0;
TimMasterHandle.Init.ClockDivision = 0;
TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
TimMasterHandle.Init.RepetitionCounter = 0;
if(HAL_TIM_PWM_Init(&TimMasterHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Configure the PWM_channel_1 */
sOCConfig.OCMode = TIM_OCMODE_PWM1;
sOCConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sOCConfig.Pulse = 64;
sOCConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sOCConfig.OCFastMode = TIM_OCFAST_DISABLE;
sOCConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
sOCConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
if (HAL_TIM_PWM_ConfigChannel(&TimMasterHandle, &sOCConfig, TIM_CHANNEL_1) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Configure TIM2 as master & use the update event as Trigger Output (TRGO) */
sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&TimMasterHandle, &sMasterConfig) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*================== End of Master configuration : TIM2 ====================*/
/*====================== Slave1 configuration : TIM3 =======================*/
/* Initialize TIM3 peripheral in PWM mode*/
TimSlave1Handle.Init.Period = 3;
TimSlave1Handle.Init.Prescaler = 0;
TimSlave1Handle.Init.ClockDivision = 0;
TimSlave1Handle.Init.CounterMode = TIM_COUNTERMODE_UP;
TimSlave1Handle.Init.RepetitionCounter = 0;
if (HAL_TIM_PWM_Init(&TimSlave1Handle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Configure the PWM_channel_1 */
sOCConfig.OCMode = TIM_OCMODE_PWM1;
sOCConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sOCConfig.Pulse = 1;
if (HAL_TIM_PWM_ConfigChannel(&TimSlave1Handle, &sOCConfig, TIM_CHANNEL_1) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Configure TIM3 in Gated slave mode &
use the Internal Trigger 1 (ITR1) as trigger source */
sSlaveConfig.SlaveMode = TIM_SLAVEMODE_GATED;
sSlaveConfig.InputTrigger = TIM_TS_ITR1;
sSlaveConfig.TriggerPolarity = TIM_TRIGGERPOLARITY_NONINVERTED;
sSlaveConfig.TriggerPrescaler = TIM_TRIGGERPRESCALER_DIV1;
sSlaveConfig.TriggerFilter = 0;
if (HAL_TIM_SlaveConfigSynchronization(&TimSlave1Handle, &sSlaveConfig) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Configure TIM3 as master & use the update event as Trigger Output (TRGO) */
sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
if( HAL_TIMEx_MasterConfigSynchronization(&TimSlave1Handle,&sMasterConfig) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*================== End of Slave1 configuration : TIM3 ====================*/
/*====================== Slave2 configuration : TIM4 =======================*/
/* Initialize TIM4 peripheral in PWM mode*/
TimSlave2Handle.Init.Period = 3;
TimSlave2Handle.Init.Prescaler = 0;
TimSlave2Handle.Init.ClockDivision = 0;
TimSlave2Handle.Init.CounterMode = TIM_COUNTERMODE_UP;
TimSlave2Handle.Init.RepetitionCounter = 0;
if (HAL_TIM_PWM_Init(&TimSlave2Handle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Configure the PWM_channel_1 */
sOCConfig.OCMode = TIM_OCMODE_PWM1;
sOCConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sOCConfig.Pulse = 1;
if (HAL_TIM_PWM_ConfigChannel(&TimSlave2Handle, &sOCConfig, TIM_CHANNEL_1) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Configure TIM4 in Gated slave mode &
use the Internal Trigger 2 (ITR2) as trigger source */
sSlaveConfig.SlaveMode = TIM_SLAVEMODE_GATED;
sSlaveConfig.InputTrigger = TIM_TS_ITR2;
if (HAL_TIM_SlaveConfigSynchronization(&TimSlave2Handle, &sSlaveConfig) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*================== End of Slave2 configuration : TIM4 ====================*/
/* Start Master PWM generation */
if (HAL_TIM_PWM_Start(&TimMasterHandle, TIM_CHANNEL_1) != HAL_OK)
{
/* PWM generation Error */
Error_Handler();
}
/* Start Slave1 PWM generation */
if (HAL_TIM_PWM_Start(&TimSlave1Handle, TIM_CHANNEL_1) != HAL_OK)
{
/* PWM generation Error */
Error_Handler();
}
/* Start Slave2 PWM generation */
if (HAL_TIM_PWM_Start(&TimSlave2Handle, TIM_CHANNEL_1) != HAL_OK)
{
/* PWM generation Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
uint8_t lcd_status = LCD_OK;
/* This sample code displays a fixed image 800x480 on LCD KoD in */
/* orientation mode landscape and DSI mode video burst */
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization: global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/* Initialize MFX */
BSP_IO_Init();
/* Initialize used Leds */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/* Configure Tamper push-button */
BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_GPIO);
/* Initialize the LCD DSI in Video Burst mode with LANDSCAPE orientation */
lcd_status = BSP_LCD_Init();
OnError_Handler(lcd_status != LCD_OK);
/* Program a line event at line 0 */
HAL_LTDC_ProgramLineEvent(&hltdc_eval, 0);
/* Copy texture to be displayed on LCD from Flash to SDRAM */
CopyPicture((uint32_t *)&candies_800x480_argb8888, (uint32_t *)LCD_FB_START_ADDRESS, 0, 0, BSP_LCD_GetXSize(), BSP_LCD_GetYSize());
BSP_LCD_LayerDefaultInit(LTDC_ACTIVE_LAYER_BACKGROUND, LCD_FB_START_ADDRESS);
BSP_LCD_SelectLayer(LTDC_ACTIVE_LAYER_BACKGROUND);
/* Prepare area to display frame number in the image displayed on LCD */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(0, 400, BSP_LCD_GetXSize(), 80);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font16);
/* Display title */
BSP_LCD_DisplayStringAt(0, 420, (uint8_t *) "LCD_DSI_ULPM_DataClock example", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 440, (uint8_t *) "Press TAMPER button to enter ULPM", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font16);
/* Infinite loop */
while (1)
{
/* Clear previous line */
BSP_LCD_ClearStringLine(460);
/* New text to display */
sprintf(str_display, ">> Frame Nb : %lu", frameCnt);
/* Print updated frame number */
BSP_LCD_DisplayStringAt(0, 460, (uint8_t *)str_display, CENTER_MODE);
if (CheckForUserInput() > 0)
{
/* Clear previous line */
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_ClearStringLine(440);
BSP_LCD_DisplayStringAt(0, 440, (uint8_t *) "Enter ULPM - switch Off LCD 6 seconds", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
/* Display Off with ULPM management Data and clock lane integrated */
BSP_LCD_DisplayOff();
HAL_Delay(1000);
/* Switch Off bit LTDCEN */
__HAL_LTDC_DISABLE(&hltdc_eval);
/* Switch Off LTDC clock */
__HAL_RCC_LTDC_CLK_DISABLE();
/* Enter ultra low power mode (data and clock lanes) */
/* This means : laneByteClock is derived from PLL.PLLR : ie ck_plldsi @ 60 MHz = 360 MHz / PLLR=6 */
/* DSI State machine start and wait until ULPM state for Data and Clock lanes, then when reached, switch off PLL DPHY */
HAL_DSI_EnterULPM(&hdsi_eval);
BSP_LED_On(LED1);
HAL_Delay(6000);
BSP_LCD_ClearStringLine(440);
BSP_LCD_DisplayStringAt(0, 440, (uint8_t *) " Exited ULPM with success - Press To enter Again ULPM. ", CENTER_MODE);
/* Switch back On LTDC clock */
__HAL_RCC_LTDC_CLK_ENABLE();
/* Switch On bit LTDCEN */
__HAL_LTDC_ENABLE(&hltdc_eval);
/* Exit ultra low power mode (data and clock lanes)
* This means : PLL DPHY is first restarted and wait until locked with its initial settings
* DSI State machine ULPM Out start and wait until ULPM state is Out for Data and Clock lanes
* laneByteClock is then switched back on PLL DPHY
*/
HAL_DSI_ExitULPM(&hdsi_eval);
BSP_LED_Off(LED1);
/* Display On with ULPM exit Data and clock lane integrated */
BSP_LCD_DisplayOn();
}
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 100 MHz */
SystemClock_Config();
/* Configure LED2 */
BSP_LED_Init(LED2);
/*##-1- Configure the I2C peripheral ######################################*/
I2cHandle.Instance = I2Cx;
I2cHandle.Init.AddressingMode = I2C_ADDRESSINGMODE_10BIT;
I2cHandle.Init.ClockSpeed = 400000;
I2cHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
I2cHandle.Init.DutyCycle = I2C_DUTYCYCLE_16_9;
I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
I2cHandle.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
I2cHandle.Init.OwnAddress1 = I2C_ADDRESS;
I2cHandle.Init.OwnAddress2 = 0xFE;
if(HAL_I2C_Init(&I2cHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
#ifdef MASTER_BOARD
/* Configure USER Button */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
/* Wait for USER Button press before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) == 1)
{
/* Toggle LED2 every 1sec */
BSP_LED_Toggle(LED2);
HAL_Delay(1000);
}
/* Wait for USER Button release before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) == 0)
{
}
BSP_LED_Off(LED2);
/* The board sends the message and expects to receive it back */
/*##-2- Start the transmission process #####################################*/
/* While the I2C in reception process, user can transmit data through
"aTxBuffer" buffer */
while(HAL_I2C_Master_Transmit_DMA(&I2cHandle, (uint16_t)I2C_ADDRESS, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
{
/* Error_Handler() function is called when Timeout error occurs.
When Acknowledge failure occurs (Slave don't acknowledge it's address)
Master restarts communication */
if (HAL_I2C_GetError(&I2cHandle) != HAL_I2C_ERROR_AF)
{
Error_Handler();
}
}
/*##-3- Wait for the end of the transfer ###################################*/
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY)
{
}
/* Wait for USER Button press before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) == 1)
{
/* Toggle LED2 every 1sec */
BSP_LED_Toggle(LED2);
HAL_Delay(1000);
}
/* Wait for USER Button release before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) == 0)
{
}
BSP_LED_Off(LED2);
/*##-4- Put I2C peripheral in reception process ###########################*/
while(HAL_I2C_Master_Receive_DMA(&I2cHandle, (uint16_t)I2C_ADDRESS, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
/* Error_Handler() function is called when Timeout error occurs.
When Acknowledge failure occurs (Slave don't acknowledge it's address)
Master restarts communication */
if (HAL_I2C_GetError(&I2cHandle) != HAL_I2C_ERROR_AF)
{
Error_Handler();
}
}
#else
/* The board receives the message and sends it back */
/*##-2- Put I2C peripheral in reception process ###########################*/
if(HAL_I2C_Slave_Receive_DMA(&I2cHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
/* Transfer error in reception process */
Error_Handler();
}
/*##-3- Wait for the end of the transfer ###################################*/
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY)
{
}
/*##-4- Start the transmission process #####################################*/
/* While the I2C in reception process, user can transmit data through
"aTxBuffer" buffer */
if(HAL_I2C_Slave_Transmit_DMA(&I2cHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
#endif /* MASTER_BOARD */
/*##-5- Wait for the end of the transfer ###################################*/
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY)
{
}
/*##-6- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer,(uint8_t*)aRxBuffer,RXBUFFERSIZE))
{
/* Processing Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
uint32_t counter = 0, transparency = 0;
uint8_t str[30];
uwInternelBuffer = (uint8_t *)0xC0260000;
/* Enable the CPU Cache */
CPU_CACHE_Enable();
/* STM32F7xx HAL library initialization:
- Configure the Flash ART accelerator on ITCM interface
- 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 200 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure LCD ######################################################*/
LCD_Config();
/* Configure TAMPER Button */
BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_GPIO);
BSP_SD_Init();
while(BSP_SD_IsDetected() != SD_PRESENT)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" Please insert SD Card ");
}
BSP_LCD_Clear(LCD_COLOR_BLACK);
/*##-2- Link the SD Card disk I/O driver ###################################*/
if(FATFS_LinkDriver(&SD_Driver, SD_Path) == 0)
{
/*##-3- Initialize the Directory Files pointers (heap) ###################*/
for (counter = 0; counter < MAX_BMP_FILES; counter++)
{
pDirectoryFiles[counter] = malloc(MAX_BMP_FILE_NAME);
if(pDirectoryFiles[counter] == NULL)
{
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" Cannot allocate memory ");
while(1)
{
}
}
}
/* Get the BMP file names on root directory */
ubNumberOfFiles = Storage_GetDirectoryBitmapFiles("/Media", pDirectoryFiles);
if (ubNumberOfFiles == 0)
{
for (counter = 0; counter < MAX_BMP_FILES; counter++)
{
free(pDirectoryFiles[counter]);
}
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" No Bitmap files... ");
while(1)
{
}
}
}
else
{
/* FatFs Initialization Error */
Error_Handler();
}
while(1)
{
counter = 0;
while ((counter) < ubNumberOfFiles)
{
/* Step1 : Display on Foreground layer -------------------------------*/
/* Format the string */
sprintf ((char*)str, "Media/%-11.11s", pDirectoryFiles[counter]);
if (Storage_CheckBitmapFile((const char*)str, &uwBmplen) == 0)
{
/* Format the string */
sprintf ((char*)str, "Media/%-11.11s", pDirectoryFiles[counter]);
/* Set LCD foreground Layer */
BSP_LCD_SelectLayer(1);
/* Open a file and copy its content to an internal buffer */
Storage_OpenReadFile(uwInternelBuffer, (const char*)str);
/* Write bmp file on LCD frame buffer */
BSP_LCD_DrawBitmap(0, 0, uwInternelBuffer);
/* Configure the transparency for background layer : Increase the transparency */
for (transparency = 0; transparency < 255; (transparency++))
{
BSP_LCD_SetTransparency(1, transparency);
/* Insert a delay of display */
HAL_Delay(2);
}
/* Wait for tamper button pressed */
while (BSP_PB_GetState(BUTTON_TAMPER) == RESET)
{
}
/* Configure the transparency for foreground layer : decrease the transparency */
for (transparency = 255; transparency > 0; transparency--)
{
BSP_LCD_SetTransparency(1, transparency);
/* Insert a delay of display */
HAL_Delay(2);
}
/* Clear the Foreground Layer */
BSP_LCD_Clear(LCD_COLOR_BLACK);
/* Jump to the next image */
counter++;
/* Step2 : Display on Background layer -----------------------------*/
/* Format the string */
sprintf ((char*)str, "Media/%-11.11s", pDirectoryFiles[counter]);
if ((Storage_CheckBitmapFile((const char*)str, &uwBmplen) == 0) || (counter < (ubNumberOfFiles)))
{
/* Connect the Output Buffer to LCD Background Layer */
BSP_LCD_SelectLayer(0);
/* Format the string */
sprintf ((char*)str, "Media/%-11.11s", pDirectoryFiles[counter]);
/* Open a file and copy its content to an internal buffer */
Storage_OpenReadFile(uwInternelBuffer, (const char*)str);
/* Write bmp file on LCD frame buffer */
BSP_LCD_DrawBitmap(0, 0, uwInternelBuffer);
/* Configure the transparency for background layer : decrease the transparency */
for (transparency = 0; transparency < 255; (transparency++))
{
BSP_LCD_SetTransparency(0, transparency);
/* Insert a delay of display */
HAL_Delay(2);
}
/* wait for tamper button pressed */
while (BSP_PB_GetState(BUTTON_TAMPER) == RESET)
{
}
/* Step3 : -------------------------------------------------------*/
/* Configure the transparency for background layer : Increase the transparency */
for (transparency = 255; transparency > 0; transparency--)
{
BSP_LCD_SetTransparency(0, transparency);
/* Insert a delay of display */
HAL_Delay(2);
}
/* Clear the Background Layer */
BSP_LCD_Clear(LCD_COLOR_BLACK);
counter++;
}
else if (Storage_CheckBitmapFile((const char*)str, &uwBmplen) == 0)
{
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(7, (uint8_t *) str);
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" File type not supported. ");
while(1)
{
}
}
}
}
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
uint32_t PlaybackPosition = PLAY_BUFF_SIZE + PLAY_HEADER;
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization: global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to have a frequency of 180 MHz */
SystemClock_Config();
/* Configure LED1 */
BSP_LED_Init(LED1);
/* Configure LED3 */
BSP_LED_Init(LED3);
/* Check if the buffer has been loaded in flash */
if(*((uint64_t *)AUDIO_FILE_ADDRESS) != 0x017EFE2446464952 ) Error_Handler();
/* Initialize playback */
Playback_Init();
/* Initialize the data buffer */
for(int i=0; i < PLAY_BUFF_SIZE; i+=2)
{
PlayBuff[i]=*((__IO uint16_t *)(AUDIO_FILE_ADDRESS + PLAY_HEADER + i));
}
/* Start the playback */
if(0 != audio_drv->Play(AUDIO_I2C_ADDRESS, NULL, 0))
{
Error_Handler();
}
if(HAL_OK != HAL_SAI_Transmit_DMA(&SaiHandle, (uint8_t *)PlayBuff, PLAY_BUFF_SIZE))
{
Error_Handler();
}
/* Start loopback */
while(1)
{
BSP_LED_Toggle(LED1);
/* Wait a callback event */
while(UpdatePointer==-1);
int position = UpdatePointer;
UpdatePointer = -1;
/* Upate the first or the second part of the buffer */
for(int i = 0; i < PLAY_BUFF_SIZE/2; i++)
{
PlayBuff[i+position] = *(uint16_t *)(AUDIO_FILE_ADDRESS + PlaybackPosition);
PlaybackPosition+=2;
}
/* check the end of the file */
if((PlaybackPosition+PLAY_BUFF_SIZE/2) > AUDIO_FILE_SIZE)
{
PlaybackPosition = PLAY_HEADER;
}
if(UpdatePointer != -1)
{
/* Buffer update time is too long compare to the data transfer time */
Error_Handler();
}
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure LED3, LED4, LED5 and LED6 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
BSP_LED_Init(LED5);
BSP_LED_Init(LED6);
/* Configure the system clock to 84 MHz */
SystemClock_Config();
/* 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()'
*/
/*
FLASH_ErrorTypeDef errorcode = HAL_FLASH_GetError();
*/
Error_Handler();
}
/* 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 */
/*
FLASH_ErrorTypeDef errorcode = HAL_FLASH_GetError();
*/
Error_Handler();
}
}
/* 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 = 0x0;
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 LED4*/
BSP_LED_On(LED4);
}
else
{
/* Error detected. Switch on LED5*/
Error_Handler();
}
/* 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 LED2 */
BSP_LED_Init(LED2);
/* Configure the system clock to 48 MHz */
SystemClock_Config();
/*##-1- Configure the TIM peripheral #######################################*/
/* ---------------------------------------------------------------------------
TIM3 configuration: PWM Input mode
In this example TIM3 input clock (TIM3CLK) is set to APB1 clock (PCLK1),
since APB1 prescaler is 1.
TIM3CLK = PCLK1
PCLK1 = HCLK
=> TIM3CLK = HCLK = SystemCoreClock
External Signal Frequency = TIM3 counter clock / TIM3_CCR2 in Hz.
External Signal DutyCycle = (TIM3_CCR1*100)/(TIM3_CCR2) in %.
--------------------------------------------------------------------------- */
/* Set TIMx instance */
TimHandle.Instance = TIMx;
/* Initialize TIMx peripheral as follows:
+ Period = 0xFFFF
+ Prescaler = 0
+ ClockDivision = 0
+ Counter direction = Up
*/
TimHandle.Init.Period = 0xFFFF;
TimHandle.Init.Prescaler = 0;
TimHandle.Init.ClockDivision = 0;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
TimHandle.Init.RepetitionCounter = 0;
if (HAL_TIM_IC_Init(&TimHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure the Input Capture channels ###############################*/
/* Common configuration */
sConfig.ICPrescaler = TIM_ICPSC_DIV1;
sConfig.ICFilter = 0;
/* Configure the Input Capture of channel 1 */
sConfig.ICPolarity = TIM_ICPOLARITY_FALLING;
sConfig.ICSelection = TIM_ICSELECTION_INDIRECTTI;
if (HAL_TIM_IC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Configure the Input Capture of channel 2 */
sConfig.ICPolarity = TIM_ICPOLARITY_RISING;
sConfig.ICSelection = TIM_ICSELECTION_DIRECTTI;
if (HAL_TIM_IC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*##-3- Configure the slave mode ###########################################*/
/* Select the slave Mode: Reset Mode */
sSlaveConfig.SlaveMode = TIM_SLAVEMODE_RESET;
sSlaveConfig.InputTrigger = TIM_TS_TI2FP2;
sSlaveConfig.TriggerPolarity = TIM_TRIGGERPOLARITY_NONINVERTED;
sSlaveConfig.TriggerPrescaler = TIM_TRIGGERPRESCALER_DIV1;
sSlaveConfig.TriggerFilter = 0;
if (HAL_TIM_SlaveConfigSynchronization(&TimHandle, &sSlaveConfig) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*##-4- Start the Input Capture in interrupt mode ##########################*/
if (HAL_TIM_IC_Start_IT(&TimHandle, TIM_CHANNEL_2) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/*##-5- Start the Input Capture in interrupt mode ##########################*/
if (HAL_TIM_IC_Start_IT(&TimHandle, TIM_CHANNEL_1) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
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 */
/* STM32F103xG 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 LED_GREEN and LED_RED */
BSP_LED_Init(LED_GREEN);
BSP_LED_Init(LED_RED);
/* Configure the system clock to 72 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(LED_GREEN);
}
}
}
}
}
}
}
}
/*##-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)
{
/* 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 LED3 */
BSP_LED_Init(LED3);
/* Compute the value of ARR regiter to generate signal frequency at 17.57 Khz */
uhTimerPeriod = (uint32_t) ((SystemCoreClock / 17570 ) - 1);
/* Compute CCR1 value to generate a duty cycle at 75% */
aCCValue_Buffer[0] = (uint32_t)(((uint32_t) 75 * (uhTimerPeriod - 1)) / 100);
/* Compute CCR2 value to generate a duty cycle at 50% */
aCCValue_Buffer[1] = (uint32_t)(((uint32_t) 50 * (uhTimerPeriod - 1)) / 100);
/* Compute CCR3 value to generate a duty cycle at 25% */
aCCValue_Buffer[2] = (uint32_t)(((uint32_t) 25 * (uhTimerPeriod - 1)) / 100);
/*##-1- Configure the TIM peripheral #######################################*/
/* ---------------------------------------------------------------------------
TIM1 input clock (TIM1CLK) is set to 2 * APB2 clock (PCLK2), since APB2
prescaler is different from 1.
TIM1CLK = 2 * PCLK2
PCLK2 = HCLK / 2
=> TIM1CLK = 2 * (HCLK / 2) = HCLK = SystemCoreClock
TIM1CLK = SystemCoreClock, Prescaler = 0, TIM1 counter clock = SystemCoreClock
SystemCoreClock is set to 168 MHz for STM32F4xx devices.
The objective is to configure TIM1 channel 3 to generate complementary PWM
signal with a frequency equal to 17.57 KHz:
- TIM1_Period = (SystemCoreClock / 17570) - 1
and a variable duty cycle that is changed by the DMA after a specific number of
Update DMA request.
The number of this repetitive requests is defined by the TIM1 Repetion counter,
each 3 Update Requests, the TIM1 Channel 3 Duty Cycle changes to the next new
value defined by the aSRC_Buffer.
Note:
SystemCoreClock variable holds HCLK frequency and is defined in system_stm32f4xx.c file.
Each time the core clock (HCLK) changes, user had to update SystemCoreClock
variable value. Otherwise, any configuration based on this variable will be incorrect.
This variable is updated in three ways:
1) by calling CMSIS function SystemCoreClockUpdate()
2) by calling HAL API function HAL_RCC_GetSysClockFreq()
3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency
-----------------------------------------------------------------------------*/
/* Initialize TIM3 peripheral as follow:
+ Period = TimerPeriod (To have an output frequency equal to 17.570 KHz)
+ Repetition Counter = 3
+ Prescaler = 0
+ ClockDivision = 0
+ Counter direction = Up
*/
TimHandle.Instance = TIMx;
TimHandle.Init.Period = uhTimerPeriod;
TimHandle.Init.RepetitionCounter = 3;
TimHandle.Init.Prescaler = 0;
TimHandle.Init.ClockDivision = 0;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure the PWM channel 3 ########################################*/
sConfig.OCMode = TIM_OCMODE_PWM1;
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfig.Pulse = aCCValue_Buffer[0];
if(HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*##-3- Start PWM signal generation in DMA mode ############################*/
if( HAL_TIM_PWM_Start_DMA(&TimHandle, TIM_CHANNEL_3, aCCValue_Buffer, 3) != HAL_OK)
{
/* Starting PWM generation Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx 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 168 MHz */
SystemClock_Config();
/* Add your application code here
*/
printf("\nAll Systems Initialized!");
printf("\n...Running Host Application Code...\n");
BSP_PB_Init(BUTTON_KEY,BUTTON_MODE_EXTI);
/* Configure LED3, LED4, LED5 and LED6 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
BSP_LED_Init(LED5);
BSP_LED_Init(LED6);
/*Configure GPIO pin : PB11 for I/O Update*/
__HAL_RCC_GPIOB_CLK_ENABLE();
GPIO_InitStruct.Pin = GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pin : PD8 for Slave Select*/
GPIO_InitStruct.Pin = GPIO_PIN_8;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pin : PD9 for Master Reset*/
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pin : PA2 for External Interrupts from ILLUM_EN*/
GPIO_InitStruct.Pin = GPIO_PIN_2;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Set the SPI parameters */
SpiHandle.Instance = SPI2;
SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
SpiHandle.Init.Direction = SPI_DIRECTION_1LINE;
SpiHandle.Init.CLKPhase = SPI_PHASE_2EDGE;
SpiHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
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.Mode = SPI_MODE_MASTER;
//Initialize DDS for Host-Control
initDDS();
resetphase();
modulation_off();
ioupdate();
printf("\nDDS Initialized for Host-Control.");
BSP_LED_On(LED3); //Status
printf("\nDDS Channel Setup Complete - Host Ready!");
////This Block makes the Host respond to ILLUM_EN
/* Enable and set External Interrupt to the highest priority */
HAL_NVIC_SetPriority(EXTI2_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(EXTI2_IRQn);
////It should come at the end of all critical initialization
/* Infinite loop */
while (1)
{
/*
for (unsigned char i =0;i<=255;i++){
phase[3] = i;
printf("\nCurrent Value = %d",i);
HAL_Delay(1000);
}
//printf("\n%d",HAL_GetTick());
*/
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure LED1, LED2, LED3 and LED4 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure Key Button, will be used to trigger an interrupt each time it's pressed.
In the ISR the PLL source will be changed from HSE to HSI, and vice versa. */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_EXTI);
/* Enable Power Control clock */
__HAL_RCC_PWR_CLK_ENABLE();
/* The voltage scaling allows optimizing the power consumption when the device is
clocked below the maximum system frequency, to update the voltage scaling value
regarding system frequency refer to product datasheet. */
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
/* Enable HSE oscillator and configure the PLL to reach the max system frequency (168MHz)
when using HSE oscillator as PLL clock source. */
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 25;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 7;
if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2 clocks dividers.
The SysTick 1 msec interrupt is required for the HAL process (Timeout management); by default
the configuration is done using the HAL_Init() API, and when the system clock configuration
is updated the SysTick configuration will be adjusted by the HAL_RCC_ClockConfig() API. */
RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* STM32F405x/407x/415x/417x Revision Z devices: prefetch is supported */
if (HAL_GetREVID() == 0x1001)
{
/* Enable the Flash prefetch */
__HAL_FLASH_PREFETCH_BUFFER_ENABLE();
}
/* Output SYSCLK divided by 2 on MCO2 pin(PC9) */
HAL_RCC_MCOConfig(RCC_MCO2, RCC_MCO2SOURCE_SYSCLK, RCC_MCODIV_2);
/* Toggle some LEDs in an infinite loop */
while (1)
{
/* Toggle LED1 */
BSP_LED_Toggle(LED1);
HAL_Delay(100);
/* Toggle LED2 */
BSP_LED_Toggle(LED2);
HAL_Delay(100);
/* Toggle LED4 */
BSP_LED_Toggle(LED4);
HAL_Delay(100);
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure LED3 and LED4 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/*##-1- Configure the SPI peripheral #######################################*/
/* Set the SPI parameters */
SpiHandle.Instance = SPIx;
SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
SpiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
SpiHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
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;
#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 USER Button */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
/* Wait for USER Button press before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) != 1)
{
BSP_LED_Toggle(LED3);
HAL_Delay(40);
}
BSP_LED_Off(LED3);
#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" */
if(HAL_SPI_TransmitReceive_DMA(&SpiHandle, (uint8_t*)aTxBuffer, (uint8_t *)aRxBuffer, BUFFERSIZE) != HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-3- Wait for the end of the transfer ###################################*/
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_SPI_GetState(&SpiHandle) != HAL_SPI_STATE_READY)
{
}
/*##-4- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer, (uint8_t*)aRxBuffer, BUFFERSIZE))
{
/* Transfer error in transmission process */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx 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: global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/* Wait until MFX is ready after reset */
HAL_Delay(100);
/* Since MFX is used, LED init is done after clock config */
/* Configure LED1 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/* Configure Tamper push-button button */
BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_GPIO);
/*##-1- Configure the RTC peripheral #######################################*/
/* Configure RTC prescaler and RTC data registers */
/* RTC configured as follows:
- Hour Format = Format 12
- Asynch Prediv = Value according to source clock
- Synch Prediv = Value according to source clock
- OutPut = Output Disable
- OutPutPolarity = High Polarity
- OutPutType = Open Drain */
__HAL_RTC_RESET_HANDLE_STATE(&RtcHandle);
RtcHandle.Instance = RTC;
RtcHandle.Init.HourFormat = RTC_HOURFORMAT_12;
RtcHandle.Init.AsynchPrediv = RTC_ASYNCH_PREDIV;
RtcHandle.Init.SynchPrediv = RTC_SYNCH_PREDIV;
RtcHandle.Init.OutPut = RTC_OUTPUT_DISABLE;
RtcHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
RtcHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
if(HAL_RTC_Init(&RtcHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure RTC Timestamp ############################################*/
RTC_TimeStampConfig();
/* Infinite loop */
while (1)
{
/*##-3- Display the updated Time and Date ################################*/
RTC_CalendarShow();
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx 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 180 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/* Timers Configuration */
/* ---------------------------------------------------------------------------
TIM1 and Timers(TIM3 and TIM4) synchronisation in parallel mode.
1/TIM1 is configured as Master Timer:
- PWM Mode is used
- The TIM1 Update event is used as Trigger Output
2/TIM3 and TIM4 are slaves for TIM1,
- PWM Mode is used
- The ITR0(TIM1) is used as input trigger for both slaves
- Gated mode is used, so starts and stops of slaves counters
are controlled by the Master trigger output signal(update event).
In this example TIM1 input clock (TIM1CLK) is set to 2 * APB2 clock (PCLK2),
since APB2 prescaler is different from 1.
TIM1CLK = 2 * PCLK2
PCLK2 = HCLK / 2
=> TIM1CLK = HCLK = SystemCoreClock
The TIM1 counter clock is equal to SystemCoreClock = 180 MHz.
The Master Timer TIM1 is running at:
TIM1 frequency = TIM1 counter clock / (TIM1_Period + 1) = 703.125 KHz
TIM1_Period = (TIM1 counter clock / TIM1 frequency) - 1 = 182
and the duty cycle is equal to: TIM1_CCR1/(TIM1_ARR + 1) = 50%
The TIM3 is running at:
(TIM1 frequency)/ ((TIM3 period +1)* (Repetition_Counter+1)) = 46.875 KHz and
a duty cycle equal to TIM3_CCR1/(TIM3_ARR + 1) = 33.3%
The TIM4 is running at:
(TIM1 frequency)/ ((TIM4 period +1)* (Repetition_Counter+1)) = 70.312 KHz and
a duty cycle equal to TIM4_CCR1/(TIM4_ARR + 1) = 50%
Note:
SystemCoreClock variable holds HCLK frequency and is defined in SystemClock_Config().
Each time the core clock (HCLK) changes, user had to update SystemCoreClock
variable value. Otherwise, any configuration based on this variable will be incorrect.
This variable is updated in three ways:
1) by calling CMSIS function SystemCoreClockUpdate()
2) by calling HAL API function HAL_RCC_GetSysClockFreq()
3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency
--------------------------------------------------------------------------- */
/* Set Timers instance */
TimMasterHandle.Instance = TIM1;
TimSlave1Handle.Instance = TIM3;
TimSlave2Handle.Instance = TIM4;
/*====================== Master configuration : TIM1 =======================*/
/* Initialize TIM1 peripheral in PWM mode*/
TimMasterHandle.Init.Period = 255;
TimMasterHandle.Init.Prescaler = 0;
TimMasterHandle.Init.ClockDivision = 0;
TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
TimMasterHandle.Init.RepetitionCounter = 4;
if (HAL_TIM_PWM_Init(&TimMasterHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Configure the PWM_channel_1 */
sOCConfig.OCMode = TIM_OCMODE_PWM1;
sOCConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sOCConfig.Pulse = 127;
sOCConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sOCConfig.OCFastMode = TIM_OCFAST_DISABLE;
sOCConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
sOCConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
if (HAL_TIM_PWM_ConfigChannel(&TimMasterHandle, &sOCConfig, TIM_CHANNEL_1) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Configure TIM1 as master & use the update event as Trigger Output (TRGO) */
sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&TimMasterHandle, &sMasterConfig) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*================== End of Master configuration : TIM1 ====================*/
/*====================== Slave1 configuration : TIM3 =======================*/
/* Initialize TIM3 peripheral in PWM mode*/
TimSlave1Handle.Init.Period = 2;
TimSlave1Handle.Init.Prescaler = 0;
TimSlave1Handle.Init.ClockDivision = 0;
TimSlave1Handle.Init.CounterMode = TIM_COUNTERMODE_UP;
TimSlave1Handle.Init.RepetitionCounter = 0;
if (HAL_TIM_PWM_Init(&TimSlave1Handle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Configure the PWM_channel_1 */
sOCConfig.OCMode = TIM_OCMODE_PWM1;
sOCConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sOCConfig.Pulse = 1;
if (HAL_TIM_PWM_ConfigChannel(&TimSlave1Handle, &sOCConfig, TIM_CHANNEL_1) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Configure TIM3 in Gated slave mode &
use the Internal Trigger 0 (ITR0) as trigger source */
sSlaveConfig.SlaveMode = TIM_SLAVEMODE_GATED;
sSlaveConfig.InputTrigger = TIM_TS_ITR0;
sSlaveConfig.TriggerPolarity = TIM_TRIGGERPOLARITY_NONINVERTED;
sSlaveConfig.TriggerPrescaler = TIM_TRIGGERPRESCALER_DIV1;
sSlaveConfig.TriggerFilter = 0;
if (HAL_TIM_SlaveConfigSynchronization(&TimSlave1Handle, &sSlaveConfig) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*================== End of Slave1 configuration : TIM3 ====================*/
/*====================== Slave2 configuration : TIM4 =======================*/
/* Initialize TIM4 peripheral in PWM mode*/
TimSlave2Handle.Init.Period = 1;
TimSlave2Handle.Init.Prescaler = 0;
TimSlave2Handle.Init.ClockDivision = 0;
TimSlave2Handle.Init.CounterMode = TIM_COUNTERMODE_UP;
TimSlave2Handle.Init.RepetitionCounter = 0;
if (HAL_TIM_PWM_Init(&TimSlave2Handle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Configure the PWM_channel_3 */
sOCConfig.OCMode = TIM_OCMODE_PWM1;
sOCConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sOCConfig.Pulse = 1;
if (HAL_TIM_PWM_ConfigChannel(&TimSlave2Handle, &sOCConfig, TIM_CHANNEL_3) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Configure TIM3 in Gated slave mode &
use the Internal Trigger 0 (ITR0) as trigger source */
sSlaveConfig.SlaveMode = TIM_SLAVEMODE_GATED;
sSlaveConfig.InputTrigger = TIM_TS_ITR0;
if (HAL_TIM_SlaveConfigSynchronization(&TimSlave2Handle, &sSlaveConfig) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*================== End of Slave2 configuration : TIM4 ====================*/
/* Start Master PWM generation */
if (HAL_TIM_PWM_Start(&TimMasterHandle, TIM_CHANNEL_1) != HAL_OK)
{
/* PWM generation Error */
Error_Handler();
}
/* Start Slave1 PWM generation */
if (HAL_TIM_PWM_Start(&TimSlave1Handle, TIM_CHANNEL_1) != HAL_OK)
{
/* PWM generation Error */
Error_Handler();
}
/* Start Slave2 PWM generation */
if (HAL_TIM_PWM_Start(&TimSlave2Handle, TIM_CHANNEL_3) != HAL_OK)
{
/* PWM generation Error */
Error_Handler();
}
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
uint32_t index = 0;
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure LED1, LED2, LED3 and LED4 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure the system clock to 168 MHz */
SystemClock_Config();
RtcHandle.Instance = RTC;
/*##-1- Configure the RTC peripheral #######################################*/
/* Configure RTC prescaler and RTC data registers */
/* RTC configured as follow:
- Hour Format = Format 24
- Asynch Prediv = Value according to source clock
- Synch Prediv = Value according to source clock
- OutPut = Output Disable
- OutPutPolarity = High Polarity
- OutPutType = Open Drain */
RtcHandle.Init.HourFormat = RTC_HOURFORMAT_24;
RtcHandle.Init.AsynchPrediv = RTC_ASYNCH_PREDIV;
RtcHandle.Init.SynchPrediv = RTC_SYNCH_PREDIV;
RtcHandle.Init.OutPut = RTC_OUTPUT_DISABLE;
RtcHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
RtcHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
if(HAL_RTC_Init(&RtcHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Clear the Tamper Flag */
__HAL_RTC_TAMPER_CLEAR_FLAG(&RtcHandle,RTC_FLAG_TAMP1F);
/*##-2- Configure RTC Tamper ###############################################*/
/* Configure RTC Tamper */
RTC_TamperConfig();
/*##-3- Write Data on the Back Up registers ################################*/
for(index = 0; index < BACKUP_COUNT; index++)
{
HAL_RTCEx_BKUPWrite(&RtcHandle,aBKPDataReg[index], 0xDF59 + (index * 0x5A));
}
/*##-4- Check Data is stored on the Back Up registers ######################*/
for(index = 0; index < BACKUP_COUNT; index++)
{
if(HAL_RTCEx_BKUPRead(&RtcHandle, aBKPDataReg[index]) != (0xDF59 + (index * 0x5A)))
{
Error_Handler();
}
}
/* Turn LED2 on */
BSP_LED_On(LED2);
/*##-5- Wait for the tamper button is pressed ##############################*/
while(TamperStatus != SET);
/*##-6- Deactivate the tamper ##############################################*/
HAL_RTCEx_DeactivateTamper(&RtcHandle, RTC_TAMPER_1);
/*##-7- Check Data is cleared on the Back Up registers #####################*/
for(index = 0; index < BACKUP_COUNT; index++)
{
if(HAL_RTCEx_BKUPRead(&RtcHandle, aBKPDataReg[index]) != 0x00)
{
Error_Handler();
}
}
/* Infinite loop */
while (1)
{
/* Toggle LED4 */
BSP_LED_Toggle(LED4);
/* Delay */
HAL_Delay(100);
}
}
/**
* @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 */
BSP_LED_Init(LED2);
/* Configure the system clock to 48 MHz */
SystemClock_Config();
/* Compute the value of ARR regiter to generate signal frequency at 17.57 Khz */
uhTimerPeriod = (uint32_t)((SystemCoreClock / 17570) - 1);
/* Compute CCR1 value to generate a duty cycle at 75% */
aCCValue_Buffer[0] = (uint32_t)(((uint32_t) 75 * (uhTimerPeriod - 1)) / 100);
/* Compute CCR2 value to generate a duty cycle at 50% */
aCCValue_Buffer[1] = (uint32_t)(((uint32_t) 50 * (uhTimerPeriod - 1)) / 100);
/* Compute CCR3 value to generate a duty cycle at 25% */
aCCValue_Buffer[2] = (uint32_t)(((uint32_t) 25 * (uhTimerPeriod - 1)) / 100);
/*##-1- Configure the TIM peripheral #######################################*/
/* ---------------------------------------------------------------------------
TIM1 input clock (TIM1CLK) is set to APB1 clock (PCLK1), since APB1
prescaler is 1.
TIM1CLK = PCLK1
PCLK1 = HCLK
=> TIM1CLK = HCLK = SystemCoreClock
TIM1CLK = SystemCoreClock, Prescaler = 0, TIM1 counter clock = SystemCoreClock
SystemCoreClock is set to 48 MHz for STM32F0xx devices.
The objective is to configure TIM1 channel 3 to generate complementary PWM
signal with a frequency equal to 17.57 KHz:
- TIM1_Period = (SystemCoreClock / 17570) - 1
and a variable duty cycle that is changed by the DMA after a specific number of
Update DMA request.
The number of this repetitive requests is defined by the TIM1 Repetion counter,
each 4 Update Requests, the TIM1 Channel 3 Duty Cycle changes to the next new
value defined by the aCCValue_Buffer.
Note:
SystemCoreClock variable holds HCLK frequency and is defined in system_stm32f0xx.c file.
Each time the core clock (HCLK) changes, user had to update SystemCoreClock
variable value. Otherwise, any configuration based on this variable will be incorrect.
This variable is updated in three ways:
1) by calling CMSIS function SystemCoreClockUpdate()
2) by calling HAL API function HAL_RCC_GetSysClockFreq()
3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency
-----------------------------------------------------------------------------*/
/* Initialize TIM1 peripheral as follows:
+ Period = TimerPeriod (To have an output frequency equal to 17.570 KHz)
+ Repetition Counter = 3
+ Prescaler = 0
+ ClockDivision = 0
+ Counter direction = Up
*/
TimHandle.Instance = TIMx;
TimHandle.Init.Period = uhTimerPeriod;
TimHandle.Init.RepetitionCounter = 3;
TimHandle.Init.Prescaler = 0;
TimHandle.Init.ClockDivision = 0;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure the PWM channel 3 ########################################*/
sConfig.OCMode = TIM_OCMODE_PWM1;
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfig.Pulse = aCCValue_Buffer[0];
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfig.OCFastMode = TIM_OCFAST_DISABLE;
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*##-3- Start PWM signal generation in DMA mode ############################*/
if (HAL_TIM_PWM_Start_DMA(&TimHandle, TIM_CHANNEL_3, aCCValue_Buffer, 3) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
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 LED4 and LED5 */
BSP_LED_Init(LED4);
BSP_LED_Init(LED5);
/* Configure the system clock to 84 MHz */
SystemClock_Config();
/*##-1- Configure the I2C peripheral #######################################*/
I2CxHandle.Instance = I2Cx;
I2CxHandle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
I2CxHandle.Init.ClockSpeed = 400000;
I2CxHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
I2CxHandle.Init.DutyCycle = I2C_DUTYCYCLE_16_9;
I2CxHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
I2CxHandle.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
I2CxHandle.Init.OwnAddress1 = I2C_ADDRESS;
I2CxHandle.Init.OwnAddress2 = 0;
if(HAL_I2C_Init(&I2CxHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
#ifdef MASTER_BOARD
/* Configure User Button */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
/* Wait for User Button press before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) != 1)
{
}
/* Wait for User Button release before starting the Communication */
while (BSP_PB_GetState(BUTTON_KEY) != 0)
{
}
while(1)
{
/* Initialize number of data variables */
hTxNumData = TXBUFFERSIZE;
hRxNumData = RXBUFFERSIZE;
/* Update bTransferRequest to send buffer write request for Slave */
bTransferRequest = MASTER_REQ_WRITE;
/*##-2- Master sends write request for slave #############################*/
while(HAL_I2C_Master_Transmit_IT(&I2CxHandle, (uint16_t)I2C_ADDRESS, (uint8_t*)&bTransferRequest, 1)!= HAL_OK)
{
/* Error_Handler() function is called when Timeout error occurs.
When Acknowledge failure occurs (Slave don't acknowledge it's address)
Master restarts communication */
if (HAL_I2C_GetError(&I2CxHandle) != HAL_I2C_ERROR_AF)
{
Error_Handler();
}
}
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2CxHandle) != HAL_I2C_STATE_READY)
{
}
/*##-3- Master sends number of data to be written ########################*/
while(HAL_I2C_Master_Transmit_IT(&I2CxHandle, (uint16_t)I2C_ADDRESS, (uint8_t*)&hTxNumData, 2)!= HAL_OK)
{
/* Error_Handler() function is called when Timeout error occurs.
When Acknowledge failure occurs (Slave don't acknowledge it's address)
Master restarts communication */
if (HAL_I2C_GetError(&I2CxHandle) != HAL_I2C_ERROR_AF)
{
Error_Handler();
}
}
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2CxHandle) != HAL_I2C_STATE_READY)
{
}
/*##-4- Master sends aTxBuffer to slave ##################################*/
while(HAL_I2C_Master_Transmit_IT(&I2CxHandle, (uint16_t)I2C_ADDRESS, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
{
/* Error_Handler() function is called when Timeout error occurs.
When Acknowledge failure occurs (Slave don't acknowledge it's address)
Master restarts communication */
if (HAL_I2C_GetError(&I2CxHandle) != HAL_I2C_ERROR_AF)
{
Error_Handler();
}
}
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2CxHandle) != HAL_I2C_STATE_READY)
{
}
/* Update bTransferRequest to send buffer read request for Slave */
bTransferRequest = MASTER_REQ_READ;
/*##-5- Master sends read request for slave ##############################*/
while(HAL_I2C_Master_Transmit_IT(&I2CxHandle, (uint16_t)I2C_ADDRESS, (uint8_t*)&bTransferRequest, 1)!= HAL_OK)
{
/* Error_Handler() function is called when Timeout error occurs.
When Acknowledge failure occurs (Slave don't acknowledge it's address)
Master restarts communication */
if (HAL_I2C_GetError(&I2CxHandle) != HAL_I2C_ERROR_AF)
{
Error_Handler();
}
}
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2CxHandle) != HAL_I2C_STATE_READY)
{
}
/*##-6- Master sends number of data to be read ###########################*/
while(HAL_I2C_Master_Transmit_IT(&I2CxHandle, (uint16_t)I2C_ADDRESS, (uint8_t*)&hRxNumData, 2)!= HAL_OK)
{
/* Error_Handler() function is called when Timeout error occurs.
When Acknowledge failure occurs (Slave don't acknowledge it's address)
Master restarts communication */
if (HAL_I2C_GetError(&I2CxHandle) != HAL_I2C_ERROR_AF)
{
Error_Handler();
}
}
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2CxHandle) != HAL_I2C_STATE_READY)
{
}
/*##-7- Master receives aRxBuffer from slave #############################*/
while(HAL_I2C_Master_Receive_IT(&I2CxHandle, (uint16_t)I2C_ADDRESS, (uint8_t*)aRxBuffer, RXBUFFERSIZE)!= HAL_OK)
{
/* Error_Handler() function is called when Timeout error occurs.
When Acknowledge failure occurs (Slave don't acknowledge it's address)
Master restarts communication */
if (HAL_I2C_GetError(&I2CxHandle) != HAL_I2C_ERROR_AF)
{
Error_Handler();
}
}
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2CxHandle) != HAL_I2C_STATE_READY)
{
}
/* Check correctness of received buffer ##################################*/
if(Buffercmp((uint8_t*)aTxBuffer,(uint8_t*)aRxBuffer,hRxNumData))
{
/* Processing Error */
Error_Handler();
}
/* Flush Rx buffers */
Flush_Buffer((uint8_t*)aRxBuffer,RXBUFFERSIZE);
/* Toggle LED4 */
BSP_LED_Toggle(LED4);
/* This delay permit the user to see LED4 toggling */
HAL_Delay(25);
}
#else
while(1)
{
/* Initialize number of data variables */
hTxNumData = 0;
hRxNumData = 0;
/*##-2- Slave receive request from master ################################*/
while(HAL_I2C_Slave_Receive_IT(&I2CxHandle, (uint8_t*)&bTransferRequest, 1)!= HAL_OK)
{
}
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2CxHandle) != HAL_I2C_STATE_READY)
{
}
/* If master request write operation #####################################*/
if (bTransferRequest == MASTER_REQ_WRITE)
{
/*##-3- Slave receive number of data to be read ########################*/
while(HAL_I2C_Slave_Receive_IT(&I2CxHandle, (uint8_t*)&hRxNumData, 2)!= HAL_OK);
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2CxHandle) != HAL_I2C_STATE_READY)
{
}
/*##-4- Slave receives aRxBuffer from master ###########################*/
while(HAL_I2C_Slave_Receive_IT(&I2CxHandle, (uint8_t*)aRxBuffer, hRxNumData)!= HAL_OK);
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2CxHandle) != HAL_I2C_STATE_READY)
{
}
/* Check correctness of received buffer ################################*/
if(Buffercmp((uint8_t*)aTxBuffer,(uint8_t*)aRxBuffer,hRxNumData))
{
/* Processing Error */
Error_Handler();
}
/* Flush Rx buffers */
Flush_Buffer((uint8_t*)aRxBuffer,RXBUFFERSIZE);
/* Toggle LED4 */
BSP_LED_Toggle(LED4);
}
/* If master request write operation #####################################*/
else
{
/*##-3- Slave receive number of data to be written #####################*/
while(HAL_I2C_Slave_Receive_IT(&I2CxHandle, (uint8_t*)&hTxNumData, 2)!= HAL_OK);
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2CxHandle) != HAL_I2C_STATE_READY)
{
}
/*##-4- Slave transmit aTxBuffer to master #############################*/
while(HAL_I2C_Slave_Transmit_IT(&I2CxHandle, (uint8_t*)aTxBuffer, RXBUFFERSIZE)!= HAL_OK);
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(&I2CxHandle) != HAL_I2C_STATE_READY)
{
}
}
}
#endif /* MASTER_BOARD */
}
/**
* @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 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
/*##-1- Configure the CRYP peripheral ######################################*/
/* 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 LED1 on */
BSP_LED_On(LED1);
}
/* 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 168 MHz */
SystemClock_Config();
/* Configure LED1, LED2 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_EXTI);
/*##-1- Check if the system has resumed from WWDG reset ####################*/
if(__HAL_RCC_GET_FLAG(RCC_FLAG_WWDGRST) != RESET)
{
/* WWDGRST flag set: Turn LED1 on */
BSP_LED_On(LED1);
/* Clear reset flags */
__HAL_RCC_CLEAR_RESET_FLAGS();
}
else
{
/* WWDGRST flag is not set: Turn LED1 off */
BSP_LED_Off(LED1);
}
/*##-2- Configure the WWDG peripheral ######################################*/
/* WWDG clock counter = (PCLK1 (42MHz)/4096)/8) = 1281 Hz (~780 us)
WWDG Window value = 80 means that the WWDG counter should be refreshed only
when the counter is below 80 (and greater than 64) otherwise a reset will
be generated.
WWDG Counter value = 127, WWDG timeout = ~780 us * 64 = 49.9 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();
}
/*##-5- Start the WWDG #####################################################*/
if(HAL_WWDG_Start(&WwdgHandle) != HAL_OK)
{
Error_Handler();
}
/* Infinite loop */
while (1)
{
/* Toggle LED2 */
BSP_LED_Toggle(LED2);
/* Insert 40 ms delay */
HAL_Delay(40);
/* Refresh WWDG: update counter value to 127, the refresh window is:
~780 * (127-80) = 36.6ms < refresh window < ~780 * 64 = 49.9ms */
if(HAL_WWDG_Refresh(&WwdgHandle, 127) != HAL_OK)
{
Error_Handler();
}
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
float x,y,z;
short sx,sy,sz;
unsigned char regVal;
unsigned char regVals[29]; //0x1D~0x39
/* STM32F103xG 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();
//uart
BSP_COM_Init(COM1, &huart);
/* Configure LED1 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/* Configure Key push-button */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
/*##-1- Configure the I2C peripheral ######################################*/
ADXL345_Init(ADXL345_I2C_COMM);
// full resolution
ADXL345_SetRangeResolution(ADXL345_RANGE_PM_2G, 1);
// enter measurement mode
ADXL345_SetPowerMode(1);
// self test mode
// regVal = ADXL345_GetRegisterValue(ADXL345_DATA_FORMAT);
// regVal |= ADXL345_SELF_TEST;
// ADXL345_SetRegisterValue(ADXL345_DATA_FORMAT, regVal);
// dump ADXL345 registers
HAL_Delay(1);
//ADXL345_GetMultiRegisterValue(ADXL345_THRESH_TAP, sizeof(regVals), regVals);
/* Infinite loop */
printf("\n\r UART Printf Example: retarget the C library printf function to the UART\n\r");
while (1)
{
ADXL345_GetGxyz(&x, &y, &z);
printf("\n\rx: %.1f, y: %.1f, z: %.1f\n\r", x, y, z);
// ADXL345_GetXyz(&sx, &sy, &sz);
// printf("\n\rx: %d, y: %d, z: %d\n\r", sx, sy, sz);
HAL_Delay(1000);
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 100 MHz */
SystemClock_Config();
/* Configure LED2 */
BSP_LED_Init(LED2);
/*##-1- Configure the TIM peripheral #######################################*/
/* Set TIMx instance */
TimHandle.Instance = TIMx;
/* Initialize TIMx peripheral as follows:
+ Period = 0xFFFF
+ Prescaler = 0
+ ClockDivision = 0
+ Counter direction = Up
*/
TimHandle.Init.Period = 0xFFFF;
TimHandle.Init.Prescaler = 0;
TimHandle.Init.ClockDivision = 0;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
if(HAL_TIM_IC_Init(&TimHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure the Input Capture channels ###############################*/
/* Common configuration */
sConfig.ICPrescaler = TIM_ICPSC_DIV1;
sConfig.ICFilter = 0;
/* Configure the Input Capture of channel 1 */
sConfig.ICPolarity = TIM_ICPOLARITY_FALLING;
sConfig.ICSelection = TIM_ICSELECTION_INDIRECTTI;
if(HAL_TIM_IC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Configure the Input Capture of channel 2 */
sConfig.ICPolarity = TIM_ICPOLARITY_RISING;
sConfig.ICSelection = TIM_ICSELECTION_DIRECTTI;
if(HAL_TIM_IC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*##-3- Configure the slave mode ###########################################*/
/* Select the slave Mode: Reset Mode */
sSlaveConfig.SlaveMode = TIM_SLAVEMODE_RESET;
sSlaveConfig.InputTrigger = TIM_TS_TI2FP2;
if(HAL_TIM_SlaveConfigSynchronization(&TimHandle, &sSlaveConfig) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*##-4- Start the Input Capture in interrupt mode ##########################*/
if(HAL_TIM_IC_Start_IT(&TimHandle, TIM_CHANNEL_2) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/*##-5- Start the Input Capture in interrupt mode ##########################*/
if(HAL_TIM_IC_Start_IT(&TimHandle, TIM_CHANNEL_1) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
uint8_t count = 0;
/* Init HAL */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Retrieve System Core Clock */
SystemCoreClock = HAL_RCC_GetHCLKFreq();
/* Initialize User_Button on STM32F4xx-Nucleo ------------------*/
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
/* Check the availability of adafruit 1.8" TFT shield on top of STM32NUCLEO
board. This is done by reading the state of IO PF.03 pin (mapped to JoyStick
available on adafruit 1.8" TFT shield). If the state of PF.03 is high then
the adafruit 1.8" TFT shield is available. */
if(TFT_ShieldDetect() == SHIELD_DETECTED)
{
#ifdef ADAFRUIT_TFT_JOY_SD_ID802
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
/* Initialize the LCD */
BSP_LCD_Init();
Display_DemoDescription();
while (1)
{
BSP_LED_Toggle(LED2);
HAL_Delay(100);
if(BSP_PB_GetState(BUTTON_USER) != RESET)
{
HAL_Delay(10);
while (BSP_PB_GetState(BUTTON_USER) != RESET);
BSP_examples[DemoIndex++].DemoFunc();
if(DemoIndex >= COUNT_OF_EXAMPLE(BSP_examples))
{
DemoIndex = 0;
}
Display_DemoDescription();
}
}
#endif /* ADAFRUIT_TFT_JOY_SD_ID802 */
}
else /* there is no AdaFruit shield 802 connected */
{
/* Initialize Led1 on STM32F4xx-Nucleo ------------------*/
BSP_LED_Init(LED1); /* this is in conflict with Adafruit shield */
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
/* 0. Wait for User button to be pressed -------------------------------------*/
while (BSP_PB_GetState(BUTTON_USER) != KEY_PRESSED)
{
/* Toggle LED3 */
BSP_LED_Toggle(LED2);
HAL_Delay(200);
}
/* Wait for User button is released */
while (BSP_PB_GetState(BUTTON_USER) != KEY_NOT_PRESSED)
{}
BSP_LED_Off(LED3);
/* Infinite loop */
while (1)
{
if(UserButtonPressed==0x01)
{
count++;
LedToggleDelay += 20*count;
UserButtonPressed = 0x00;
if(LedToggleDelay>500)
{
LedToggleDelay = 20;
count = 0;
}
}
/* Toggle LED1 & LED2 */
BSP_LED_Toggle(LED1);
HAL_Delay(LedToggleDelay);
BSP_LED_Toggle(LED2);
HAL_Delay(LedToggleDelay);
}
}
}