int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
HAL_GPIO_WritePin(Led_gpio,Led_pin,GPIO_PIN_SET);
HAL_Delay(1000);
HAL_GPIO_WritePin(Led_gpio,Led_pin,GPIO_PIN_RESET);
/* This is the buffer where we will store our message. */
uint8_t buffer[12]={0};
size_t message_length;
bool status;
/* Encode our message */
{
/* Allocate space on the stack to store the message data.
*
* Nanopb generates simple struct definitions for all the messages.
* - check out the contents of simple.pb.h!
* It is a good idea to always initialize your structures
* so that you do not have garbage data from RAM in there.
*/
SimpleMessage message = SimpleMessage_init_zero;
/* Create a stream that will write to our buffer. */
pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
/* Fill in the lucky number */
message.lucky_number = 13;
/* Now we are ready to encode the message! */
status = pb_encode(&stream, SimpleMessage_fields, &message);
message_length = stream.bytes_written;
/* Then just check for any errors.. */
if (!status)
{
//printf("Encoding failed: %s\n", PB_GET_ERROR(&stream));
return 1;
}
}
/* Now we could transmit the message over network, store it in a file or
* wrap it to a pigeon's leg.
*/
/* But because we are lazy, we will just decode it immediately. */
{
/* Allocate space for the decoded message. */
SimpleMessage message2 = SimpleMessage_init_zero;
/* Create a stream that reads from the buffer. */
pb_istream_t stream2 = pb_istream_from_buffer(buffer, message_length);
/* Now we are ready to decode the message. */
status = pb_decode(&stream2, SimpleMessage_fields, &message2);
/* Check for errors... */
if (!status)
{
//printf("Decoding failed: %s\n", PB_GET_ERROR(&stream));
// return 1;
}
/* Print the data contained in the message. */
//printf("Your lucky number was %d!\n", message.lucky_number);
}
while (1)
{
HAL_GPIO_TogglePin(Led_gpio,Led_pin);
HAL_Delay(500);
}
}
/**
* @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);
/* Compute the prescaler value to have TIM1 counter clock equal to 18MHz */
uwPrescalerValue = (uint32_t) ((SystemCoreClock / 18000000) - 1);
/*##-1- Configure the TIM peripheral #######################################*/
/* ---------------------------------------------------------------------------
1/ Generate 3 complementary PWM signals with 3 different duty cycles:
TIM1 input clock (TIM1CLK) is set to 2 * APB2 clock (PCLK2), since APB2
prescaler is different from 1.
TIM1CLK = 2 * PCLK2
PCLK1 = HCLK / 2
=> TIM1CLK = HCLK = SystemCoreClock
TIM1CLK is fixed to SystemCoreClock, the TIM1 Prescaler is set to have
TIM1 counter clock = 18MHz.
The objective is to generate PWM signal at 10 KHz:
- TIM1_Period = (TIM1 counter clock / 10000) - 1
The Three Duty cycles are computed as the following description:
The channel 1 duty cycle is set to 50% so channel 1N is set to 50%.
The channel 2 duty cycle is set to 25% so channel 2N is set to 75%.
The channel 3 duty cycle is set to 12.5% so channel 3N is set to 87.5%.
The Timer pulse is calculated as follows:
- ChannelxPulse = DutyCycle * (TIM1_Period - 1) / 100
2/ Insert a dead time equal to (100/SystemCoreClock) us
3/ Configure the break feature, active at High level, and using the automatic
output enable feature
4/ Use the Locking parameters level1.
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 TIM peripheral as follows:
+ Prescaler = (SystemCoreClock/18000000) - 1
+ Period = (1800 - 1) (to have an output frequency equal to 10 KHz)
+ ClockDivision = 0
+ Counter direction = Up
*/
/* Select the Timer instance */
TimHandle.Instance = TIM1;
TimHandle.Init.Prescaler = uwPrescalerValue;
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 */
sPWMConfig.OCMode = TIM_OCMODE_PWM1;
sPWMConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sPWMConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sPWMConfig.OCIdleState = TIM_OCIDLESTATE_SET;
sPWMConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
sPWMConfig.OCFastMode = TIM_OCFAST_DISABLE;
/* Set the pulse value for channel 1 */
sPWMConfig.Pulse = PULSE1_VALUE;
if(HAL_TIM_PWM_ConfigChannel(&TimHandle, &sPWMConfig, TIM_CHANNEL_1) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Set the pulse value for channel 2 */
sPWMConfig.Pulse = PULSE2_VALUE;
if(HAL_TIM_PWM_ConfigChannel(&TimHandle, &sPWMConfig, TIM_CHANNEL_2) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Set the pulse value for channel 3 */
sPWMConfig.Pulse = PULSE3_VALUE;
if(HAL_TIM_PWM_ConfigChannel(&TimHandle, &sPWMConfig, TIM_CHANNEL_3) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Set the Break feature & Dead time */
sBreakConfig.BreakState = TIM_BREAK_ENABLE;
sBreakConfig.DeadTime = 100;
sBreakConfig.OffStateRunMode = TIM_OSSR_ENABLE;
sBreakConfig.OffStateIDLEMode = TIM_OSSI_ENABLE;
sBreakConfig.LockLevel = TIM_LOCKLEVEL_1;
sBreakConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
sBreakConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_ENABLE;
if(HAL_TIMEx_ConfigBreakDeadTime(&TimHandle, &sBreakConfig) != 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)
{
/* Starting Error */
Error_Handler();
}
/* Start channel 1N */
if(HAL_TIMEx_PWMN_Start(&TimHandle, TIM_CHANNEL_1) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Start channel 2 */
if(HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Start channel 2N */
if(HAL_TIMEx_PWMN_Start(&TimHandle, TIM_CHANNEL_2) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Start channel 3 */
if(HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Start channel 3N */
if(HAL_TIMEx_PWMN_Start(&TimHandle, TIM_CHANNEL_3) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
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 LED4 */
BSP_LED_Init(LED4);
/* Configure the system clock to 48 MHz */
SystemClock_Config();
/*##-1- Configure the TIM peripheral #######################################*/
/* TIM1 configuration: Input Capture mode ---------------------
The external signal is connected to TIM1 CH2 pin (PA.09)
The Rising edge is used as active edge,
The TIM1 CCR2 is used to compute the frequency value
------------------------------------------------------------ */
/* 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 channel ################################*/
/* Configure the Input Capture of channel 2 */
sICConfig.ICPolarity = TIM_ICPOLARITY_RISING;
sICConfig.ICSelection = TIM_ICSELECTION_DIRECTTI;
sICConfig.ICPrescaler = TIM_ICPSC_DIV1;
sICConfig.ICFilter = 0;
if(HAL_TIM_IC_ConfigChannel(&TimHandle, &sICConfig, TIM_CHANNEL_2) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*##-3- Start the Input Capture in interrupt mode ##########################*/
if(HAL_TIM_IC_Start_IT(&TimHandle, TIM_CHANNEL_2) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
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 LED4 */
BSP_LED_Init(LED4);
/* 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)
{
float capacitanceratio;
/* 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();
/******* Initialize LEDs available on STM32303E-EVAL RevC board ******************/
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure the system clock to 72 MHz */
SystemClock_Config();
/*##-1- Initialize the Key push-button and Joystick ####################################*/
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
BSP_JOY_Init(JOY_MODE_GPIO);
/*##-2- Initialize the LCD #################################################*/
/* Initialize the LCD */
BSP_LCD_Init();
/*##-3- Display messages on LCD ############################################*/
/* Display Example Welcome message */
Display_ExampleDescription();
/* Wait For User inputs */
while (1)
{
if (BSP_PB_GetState(BUTTON_KEY) == GPIO_PIN_RESET)
{
while (BSP_PB_GetState(BUTTON_KEY) == GPIO_PIN_RESET);
break;
}
}
/* Display Example Template */
HYGROMETER_SetHint();
/*##-4- Configure DACx #####################################################*/
/* configure DACx */
DACx_Config();
/*##-5- Configure Comparators ##############################################*/
/* configure COMPx */
COMPx_Config();
/*##-6- Configure Timers ###################################################*/
TIM3_Config();
TIM4_Config();
/*##-7- Start Example ######################################################*/
/* wait until first AvrgICReadValue is calculated */
while(AvrgICReadValue == 0);
/* Enter Calibration menu */
Calibration_Menu();
/* Infinite loop */
while (1)
{
/* Calculate Trigger Time Value */
TriggerTime = (float) (AvrgICReadValue-ICError)/SystemCoreClock;
/* Comp4 inverted input connected to DACx :
* TriggerTime = RES * Capacitance * ln(VDD/(VDD - VREF))
* @VREF = 2.086V (generated by DAC), ln(VDD/(VDD - VREF)) is ~ 1
* ==> Capacitance = TriggerTime/RES
*/
Capacitance = (float) TriggerTime/RES;
/* Calculate humidity value using reversed polynomial expression */
capacitanceratio = Capacitance/Capacitance55RH;
/* RH (%) = -3.4656*10^3 * X^3 + 1.0732*10^4 * X^2 - 1.0457*10^4*X + 3.2459*10^3
with X = C (read) / C@55%RH = capacitanceratio */
RelativeHumidity = RP3 * pow(capacitanceratio, 3) +
RP2 * pow(capacitanceratio, 2) +
RP1 * capacitanceratio +
RP0;
/* Restrict Relative Humidity Value to 0-99 Domain */
if (RelativeHumidity < 0)
{
RelativeHumidity = 0;
}
if (RelativeHumidity > 99)
{
RelativeHumidity = 99;
}
/* Display the humidity value */
Display_Humidity((uint32_t) RelativeHumidity);
}
}
/**
* @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);
/* Initialize 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 */
__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();
}
/* 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);
}
}
int main(void) {
// TODO disable JTAG
/* 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();
// set the system clock to be HSE
SystemClock_Config();
// enable GPIO clocks
__GPIOA_CLK_ENABLE();
__GPIOB_CLK_ENABLE();
__GPIOC_CLK_ENABLE();
__GPIOD_CLK_ENABLE();
// enable the CCM RAM
__CCMDATARAMEN_CLK_ENABLE();
#if 0
#if defined(NETDUINO_PLUS_2)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
#if MICROPY_HW_HAS_SDCARD
// Turn on the power enable for the sdcard (PB1)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_WriteBit(GPIOB, GPIO_Pin_1, Bit_SET);
#endif
// Turn on the power for the 5V on the expansion header (PB2)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_WriteBit(GPIOB, GPIO_Pin_2, Bit_SET);
}
#endif
#endif
// basic sub-system init
pendsv_init();
led_init();
switch_init0();
int first_soft_reset = true;
uint reset_mode;
soft_reset:
// check if user switch held to select the reset mode
reset_mode = 1;
led_state(1, 0);
led_state(2, 1);
led_state(3, 0);
led_state(4, 0);
#if MICROPY_HW_HAS_SWITCH
if (switch_get()) {
for (uint i = 0; i < 3000; i++) {
if (!switch_get()) {
break;
}
HAL_Delay(20);
if (i % 30 == 29) {
reset_mode = (reset_mode + 1) & 7;
led_state(2, reset_mode & 1);
led_state(3, reset_mode & 2);
led_state(4, reset_mode & 4);
}
}
// flash the selected reset mode
for (uint i = 0; i < 6; i++) {
led_state(2, 0);
led_state(3, 0);
led_state(4, 0);
HAL_Delay(50);
led_state(2, reset_mode & 1);
led_state(3, reset_mode & 2);
led_state(4, reset_mode & 4);
HAL_Delay(50);
}
HAL_Delay(400);
}
#endif
#if MICROPY_HW_ENABLE_RTC
if (first_soft_reset) {
rtc_init();
}
#endif
// more sub-system init
#if MICROPY_HW_HAS_SDCARD
if (first_soft_reset) {
sdcard_init();
}
#endif
if (first_soft_reset) {
storage_init();
}
// GC init
gc_init(&_heap_start, &_heap_end);
// Change #if 0 to #if 1 if you want REPL on USART_6 (or another usart)
// as well as on USB VCP
#if 0
pyb_usart_global_debug = pyb_Usart(MP_OBJ_NEW_SMALL_INT(PYB_USART_YA),
MP_OBJ_NEW_SMALL_INT(115200));
#else
pyb_usart_global_debug = NULL;
#endif
// Micro Python init
qstr_init();
mp_init();
mp_obj_t def_path[3];
def_path[0] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_);
def_path[1] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_src);
def_path[2] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_lib);
mp_sys_path = mp_obj_new_list(3, def_path);
readline_init();
exti_init();
#if MICROPY_HW_HAS_SWITCH
// must come after exti_init
switch_init();
#endif
#if MICROPY_HW_HAS_LCD
// LCD init (just creates class, init hardware by calling LCD())
lcd_init();
#endif
pin_map_init();
// local filesystem init
{
// try to mount the flash
FRESULT res = f_mount(&fatfs0, "0:", 1);
if (reset_mode == 3 || res == FR_NO_FILESYSTEM) {
// no filesystem, or asked to reset it, so create a fresh one
// LED on to indicate creation of LFS
led_state(PYB_LED_R2, 1);
uint32_t start_tick = HAL_GetTick();
res = f_mkfs("0:", 0, 0);
if (res == FR_OK) {
// success creating fresh LFS
} else {
__fatal_error("could not create LFS");
}
// create src directory
res = f_mkdir("0:/src");
// ignore result from mkdir
// create empty main.py
FIL fp;
f_open(&fp, "0:/src/main.py", FA_WRITE | FA_CREATE_ALWAYS);
UINT n;
f_write(&fp, fresh_main_py, sizeof(fresh_main_py) - 1 /* don't count null terminator */, &n);
// TODO check we could write n bytes
f_close(&fp);
// keep LED on for at least 200ms
sys_tick_wait_at_least(start_tick, 200);
led_state(PYB_LED_R2, 0);
} else if (res == FR_OK) {
// mount sucessful
} else {
__fatal_error("could not access LFS");
}
}
// make sure we have a /boot.py
{
FILINFO fno;
#if _USE_LFN
fno.lfname = NULL;
fno.lfsize = 0;
#endif
FRESULT res = f_stat("0:/boot.py", &fno);
if (res == FR_OK) {
if (fno.fattrib & AM_DIR) {
// exists as a directory
// TODO handle this case
// see http://elm-chan.org/fsw/ff/img/app2.c for a "rm -rf" implementation
} else {
// exists as a file, good!
}
} else {
// doesn't exist, create fresh file
// LED on to indicate creation of boot.py
led_state(PYB_LED_R2, 1);
uint32_t start_tick = HAL_GetTick();
FIL fp;
f_open(&fp, "0:/boot.py", FA_WRITE | FA_CREATE_ALWAYS);
UINT n;
f_write(&fp, fresh_boot_py, sizeof(fresh_boot_py) - 1 /* don't count null terminator */, &n);
// TODO check we could write n bytes
f_close(&fp);
// keep LED on for at least 200ms
sys_tick_wait_at_least(start_tick, 200);
led_state(PYB_LED_R2, 0);
}
}
// run /boot.py
if (reset_mode == 1) {
if (!pyexec_file("0:/boot.py")) {
flash_error(4);
}
}
// turn boot-up LEDs off
led_state(2, 0);
led_state(3, 0);
led_state(4, 0);
#if defined(USE_DEVICE_MODE)
usb_storage_medium_t usb_medium = USB_STORAGE_MEDIUM_FLASH;
#endif
#if MICROPY_HW_HAS_SDCARD
// if an SD card is present then mount it on 1:/
if (reset_mode == 1 && sdcard_is_present()) {
FRESULT res = f_mount(&fatfs1, "1:", 1);
if (res != FR_OK) {
printf("[SD] could not mount SD card\n");
} else {
if (first_soft_reset) {
// use SD card as medium for the USB MSD
#if defined(USE_DEVICE_MODE)
usb_medium = USB_STORAGE_MEDIUM_SDCARD;
#endif
}
}
}
#else
// Get rid of compiler warning if no SDCARD is configured.
(void)first_soft_reset;
#endif
#if defined(USE_HOST_MODE)
// USB host
pyb_usb_host_init();
#elif defined(USE_DEVICE_MODE)
// USB device
if (reset_mode == 1) {
usb_device_mode_t usb_mode = USB_DEVICE_MODE_CDC_MSC;
if (pyb_config_usb_mode != MP_OBJ_NULL) {
if (strcmp(mp_obj_str_get_str(pyb_config_usb_mode), "CDC+HID") == 0) {
usb_mode = USB_DEVICE_MODE_CDC_HID;
}
}
pyb_usb_dev_init(usb_mode, usb_medium);
} else {
pyb_usb_dev_init(USB_DEVICE_MODE_CDC_MSC, usb_medium);
}
#endif
#if MICROPY_HW_ENABLE_RNG
// RNG
rng_init();
#endif
// I2C
i2c_init();
#if MICROPY_HW_HAS_MMA7660
// MMA accel: init and reset
accel_init();
#endif
#if MICROPY_HW_ENABLE_SERVO
// servo
servo_init();
#endif
#if 0
#if MICROPY_HW_ENABLE_TIMER
// timer
timer_init();
#endif
#endif
#if MICROPY_HW_ENABLE_DAC
// DAC
dac_init();
#endif
// run main script
if (reset_mode == 1) {
vstr_t *vstr = vstr_new();
vstr_add_str(vstr, "0:/");
if (pyb_config_source_dir == MP_OBJ_NULL) {
vstr_add_str(vstr, "src");
} else {
vstr_add_str(vstr, mp_obj_str_get_str(pyb_config_source_dir));
}
vstr_add_char(vstr, '/');
if (pyb_config_main == MP_OBJ_NULL) {
vstr_add_str(vstr, "main.py");
} else {
vstr_add_str(vstr, mp_obj_str_get_str(pyb_config_main));
}
if (!pyexec_file(vstr_str(vstr))) {
flash_error(3);
}
vstr_free(vstr);
}
#if 0
#if MICROPY_HW_HAS_WLAN
// wifi
pyb_wlan_init();
pyb_wlan_start();
#endif
#endif
// enter REPL
// REPL mode can change, or it can request a soft reset
for (;;) {
if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
if (pyexec_raw_repl() != 0) {
break;
}
} else {
if (pyexec_friendly_repl() != 0) {
break;
}
}
}
printf("PYB: sync filesystems\n");
storage_flush();
printf("PYB: soft reboot\n");
first_soft_reset = false;
goto soft_reset;
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F0xx HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Low Level Initialization
*/
HAL_Init();
/* Configure LED2 */
BSP_LED_Init(LED2);
/* Configure the system clock to 48 MHz */
SystemClock_Config();
/*##-1- Configure the TIM peripheral #######################################*/
/* -----------------------------------------------------------------------
In this example TIM3 input clock (TIM3CLK) is set to APB1 clock (PCLK1),
since APB1 prescaler is equal to 1.
TIM3CLK = PCLK1
PCLK1 = HCLK
=> TIM3CLK = HCLK = SystemCoreClock
To get TIM3 counter clock at 10 KHz, the Prescaler is computed as following:
Prescaler = (TIM3CLK / TIM3 counter clock) - 1
Prescaler = (SystemCoreClock /10 KHz) - 1
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
----------------------------------------------------------------------- */
/* Compute the prescaler value to have TIMx counter clock equal to 10000 Hz */
uwPrescalerValue = (uint32_t)(SystemCoreClock / 10000) - 1;
/* Set TIMx instance */
TimHandle.Instance = TIMx;
/* Initialize TIMx peripheral as follows:
+ Period = 10000 - 1
+ Prescaler = (SystemCoreClock/10000) - 1
+ ClockDivision = 0
+ Counter direction = Up
*/
TimHandle.Init.Period = 10000 - 1;
TimHandle.Init.Prescaler = uwPrescalerValue;
TimHandle.Init.ClockDivision = 0;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
TimHandle.Init.RepetitionCounter = 0;
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Start the TIM Base generation in interrupt mode ####################*/
/* Start Channel1 */
if (HAL_TIM_Base_Start_IT(&TimHandle) != 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 the system clock to 180 MHz */
SystemClock_Config();
/* Configure LED1 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/*##-1- Configure the TIM peripheral #######################################*/
/* ---------------------------------------------------------------------------
TIM3 Configuration: Output Compare Toggle Mode:
In this example TIM3 input clock (TIM3CLK) is set to 2 * APB1 clock (PCLK1),
since APB1 prescaler is different from 1.
TIM3CLK = 2 * PCLK1
PCLK1 = HCLK / 4
=> TIM3CLK = HCLK / 2 = SystemCoreClock /2
To get TIM3 counter clock at 18 MHz, the prescaler is computed as follows:
Prescaler = (TIM3CLK / TIM3 counter clock) - 1
Prescaler = ((SystemCoreClock /2) /18 MHz) - 1
CC1 update rate = TIM3 counter clock / uhCCR1_Val = 439.44 Hz
==> So the TIM3 Channel 1 generates a periodic signal with a
frequency equal to 219.72 Hz.
CC2 update rate = TIM3 counter clock / uhCCR2_Val = 878.9 Hz
==> So the TIM3 Channel 2 generates a periodic signal with a
frequency equal to 439.45 Hz.
CC3 update rate = TIM3 counter clock / uhCCR3_Val = 1757.81 Hz
==> So the TIM3 Channel 3 generates a periodic signal with a
frequency equal to 878.9 Hz.
CC4 update rate = TIM3 counter clock / uhCCR4_Val = 3515.62 Hz
==> So the TIM3 Channel 4 generates a periodic signal with a
frequency equal to 1757.81 Hz.
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
--------------------------------------------------------------------------- */
/* Compute the prescaler value to have TIMx counter clock equal to 21 MHz */
uwPrescalerValue = (uint32_t)(((SystemCoreClock /2) / 18000000) - 1);
/* Initialize TIMx peripheral as follow:
+ Prescaler = ((SystemCoreClock /2) / 18000000) - 1
+ Period = 65535
+ ClockDivision = 0
+ Counter direction = Up
*/
TimHandle.Instance = TIMx;
TimHandle.Init.Period = 65535;
TimHandle.Init.Prescaler = uwPrescalerValue;
TimHandle.Init.ClockDivision = 0;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
if(HAL_TIM_OC_Init(&TimHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure the Output Compare channels ##############################*/
/* Output Compare Toggle Mode configuration: Channel1 */
sConfig.OCMode = TIM_OCMODE_TOGGLE;
sConfig.Pulse = uhCCR1_Val;
sConfig.OCPolarity = TIM_OCPOLARITY_LOW;
if(HAL_TIM_OC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Output Compare Toggle Mode configuration: Channel2 */
sConfig.Pulse = uhCCR2_Val;
if(HAL_TIM_OC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Output Compare Toggle Mode configuration: Channel3 */
sConfig.Pulse = uhCCR3_Val;
if(HAL_TIM_OC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Output Compare Toggle Mode configuration: Channel4 */
sConfig.Pulse = uhCCR4_Val;
if(HAL_TIM_OC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*##-3- Start signals generation ###########################################*/
/* Start channel 1 in Output compare mode */
if(HAL_TIM_OC_Start_IT(&TimHandle, TIM_CHANNEL_1) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Start channel 2 in Output compare mode */
if(HAL_TIM_OC_Start_IT(&TimHandle, TIM_CHANNEL_2) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Start channel 3 in Output compare mode */
if(HAL_TIM_OC_Start_IT(&TimHandle, TIM_CHANNEL_3) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Start channel 4 in Output compare mode */
if(HAL_TIM_OC_Start_IT(&TimHandle, TIM_CHANNEL_4) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* This sample code shows how to use STM32F7xx CEC HAL API to transmit and
* receive data. The device is set in waiting to receive mode and sends
* messages when the evaluation board buttons are pushed by the user */
/* Configure the MPU attributes as Write Through */
MPU_Config();
/* Enable the CPU Cache */
CPU_CACHE_Enable();
/* STM32F7xx HAL library initialization:
- Configure the Flash ART accelerator
- 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 200 MHz MHz */
SystemClock_Config();
/*##-1- Initialize the SDRAM ##############################################*/
BSP_SDRAM_Init();
/*##-2- Initialize the LCD #################################################*/
BSP_LCD_Init();
BSP_LCD_LayerDefaultInit(1, LCD_FRAME_BUFFER);
/* Enable the LCD */
BSP_LCD_DisplayOn();
/* Select the LCD Foreground layer */
BSP_LCD_SelectLayer(1);
/* Display test description on screen */
CEC_SetHint();
/* -2- Configure touch screen */
BSP_TS_Init(BSP_LCD_GetXSize(), BSP_LCD_GetYSize());
BSP_TS_ITConfig(); /* Touch screen interrupt configuration and enable */
/* -3- CEC configuration (transfer will take place in Interrupt mode) */
#if defined (DEVICE_1)
DestinationAddress = DEVICE_ADDRESS_2; /* follower address */
#elif defined (DEVICE_2)
DestinationAddress = DEVICE_ADDRESS_1; /* follower address */
#endif
hcec.Instance = CEC;
/* Deinitialize CEC to reinitialize from scratch */
HAL_CEC_DeInit(&hcec);
/* IP configuration */
CEC_Config(&hcec);
/* -4- CEC transfer general variables initialization */
ReceivedFrame = 0;
StartSending = 0;
NbOfReceivedBytes = 0;
CEC_FlushRxBuffer();
/* Test start */
/* Enter infinite reception loop: the CEC device is set in
* waiting to receive mode.
* The CEC "background" state is HAL_CEC_STATE_STANDBY_RX.
* Upon any message reception or transmission, the CEC
* comes back to that state.
* It is up to the user to define exit conditions in modifying
* accordingly the RX, TX or Error callback functions. */
HAL_CEC_Receive_IT(&hcec, (uint8_t *)&Tab_Rx);
while (HAL_CEC_GetState(&hcec) != HAL_CEC_STATE_READY)
{
/* if no reception has occurred and no error has been detected,
* transmit a message if the user has pushed a button */
if( (StartSending == 1) && (ReceivedFrame == 0))
{
HAL_CEC_Transmit_IT(&hcec, DestinationAddress, (uint8_t *)&Tab_Tx, TxSize);
/* loop until TX ends or TX error reported */
while (HAL_CEC_GetState(&hcec) != HAL_CEC_STATE_STANDBY_RX);
StartSending = 0;
}
/* if a frame has been received */
if (ReceivedFrame == 1)
{
if (Tab_Rx[1] == 0x44) /* Test on the opcode value */
{
/* Receive command is equal to Command 1 */
if (Tab_Rx[2] == 0x41) /* Test on the operand value */
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+30, (uint8_t *)" Received opcode 44, operand 41 ", CENTER_MODE);
}
else if (Tab_Rx[2] == 0x42) /* Receive command is equal to Command 2 */
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+30, (uint8_t *)" Received opcode 44, operand 42 ", CENTER_MODE);
}
}
else if (Tab_Rx[1] == 0x46) /* Test on the opcode value */
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_ORANGE);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+30, (uint8_t *)" Received opcode 46 ", CENTER_MODE);
}
else if (Tab_Rx[1] == 0x9F) /* Test on the opcode value */
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_DARKMAGENTA);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+30, (uint8_t *)" Received opcode 9F ", CENTER_MODE);
}
ReceivedFrame = 0;
}
else if (ReceivedFrame == 2) /* means CEC error detected */
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+45, (uint8_t *)" CEC Error ", CENTER_MODE);
ReceivedFrame = 0;
}
} /* while (HAL_CEC_GetState(&hcec) != HAL_CEC_STATE_READY) */
return 0;
}
int main()//OPTIMIZATION LEVEL = 0
{
HAL_Init();
SystemClockConfig();
ConfigLED();
ConfigTimer();
rtksvrstart(&svr);
ConfigUART(svr.format[0]);
fobs[0]=fobs[1]=0;
//svr.raw[1].time.time = 1429540822;//test SS2 data
//svr.raw[1].time.time = 1429539852;//test SS2 data
while (HAL_UART_Receive_DMA(&UartGPSHandle,svr.buff[0],MAX_RAW_LEN) != HAL_OK);
while (HAL_UART_Receive_DMA(&UartRFHandle,svr.buff[1],MAX_RAW_LEN) != HAL_OK);
HAL_Delay(3000);
sendRequest(svr.format[0]);
// test();
while(1)
{
#ifndef _TEST_RESULT
if (flagTimeout)
{
int index,temp;
flagTimeout=0;
//SendIntStr(UartGPSHandle.Instance->SR);
//SendIntStr(UartRFHandle.Instance->SR);
for (index=0;index<2;index++)
{
if (index==0)
temp = UartGPSHandle.hdmarx->Instance->NDTR & 0xffff;
else
temp = UartRFHandle.hdmarx->Instance->NDTR & 0xffff;
if (temp + svr.buffPtr[index] <= MAX_RAW_LEN)
svr.nb[index] = MAX_RAW_LEN - svr.buffPtr[index] - temp;
else
svr.nb[index] = 2*MAX_RAW_LEN - temp - svr.buffPtr[index];
fobs[index] = decode_raw(&svr,index);
svr.buffPtr[index] = MAX_RAW_LEN - temp;
}
// temp = UartGPSHandle.hdmarx->Instance->NDTR & 0xffff;
// if (temp + svr.buffPtr[0] <= MAX_RAW_LEN)
// svr.nb[0] = MAX_RAW_LEN - svr.buffPtr[0] - temp;
// else
// svr.nb[0] = 2*MAX_RAW_LEN - temp - svr.buffPtr[0];
// if (svr.buffPtr[0] + svr.nb[0] <= MAX_RAW_LEN)
// {
// for (i = svr.buff[0] + svr.buffPtr[0] ;
// i < svr.buff[0] + svr.buffPtr[0] + svr.nb[0]; i++)
// {
// HAL_UART_Transmit(&UartResultHandle,i,1,1);
// }
// }
// else
// {
// for (i = svr.buff[0] + svr.buffPtr[0] ;
// i < svr.buff[0] + MAX_RAW_LEN; i++)
// {
// HAL_UART_Transmit(&UartResultHandle,i,1,1);
// }
// for (i = svr.buff[0] ;
// i < svr.buff[0] + svr.nb[0] + svr.buffPtr[0] - MAX_RAW_LEN ; i++)
// {
// HAL_UART_Transmit(&UartResultHandle,i,1,1);
// }
// }
// svr.buffPtr[0] = MAX_RAW_LEN - temp;
//rtk positioning**********************************************************************
// if (0)
if (fobs[1])
{
fobs[1]=0;
LED4_TOGGLE;
}
if (fobs[0])
{
int i;
fobs[0]=0;
LED3_TOGGLE;
#ifdef TIME_MEASURE
start=HAL_GetTick();
#endif
temp=svr.obs[0].n;
for (i=0;i<temp;i++)
{
obsd[i]=svr.obs[0].data[i];
}
for (i=0;(i<svr.obs[1].n)&&(i+temp<MAX_OBS);i++)
{
obsd[i+temp]=svr.obs[1].data[i];
}
if (!rtkpos(&svr.rtk,obsd,i+temp,&svr.nav))
// if (1)
{
LED5_TOGGLE;
#ifdef TIME_MEASURE
t=HAL_GetTick()-start;
svr.rtk.sol.processTime = t;
#endif
if (svr.rtk.sol.stat==SOLQ_FIX)
LED6_TOGGLE;
outsol(&svr.rtk.sol,svr.rtk.rb);
SendStr(svr.rtk.sol.result);
}
else
{
HAL_UART_Transmit_DMA(&UartResultHandle,(unsigned char*)svr.rtk.errbuf,svr.rtk.errLen);
}
}
}
#else
if (flagTimeout)
{
static int i;
char* res = svr.rtk.sol.result;
flagTimeout = 0;
res+=sprintf(res,
"%04.0f/%02.0f/%02.0f %02.0f:%02.0f:%06.3f %14.4f %14.4f %14.4f %3d %3d %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %6.2f %6.1f",
2015.0,10.0,12.0,3.0,45.0,18.0,//time yy/mm/dd hh:mm:ss.ssss
1.0,2.0,1.0,
1,1,
1.0,1.0,1.0,
1.0,1.0,1.0,
1.0,1.0);
res+=sprintf(res," %4d",i++);
res[0]='\n';
SendStr(svr.rtk.sol.result);
}
#endif
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F103xB 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 64 MHz */
SystemClock_Config();
/* Configure LED2 */
BSP_LED_Init(LED2);
/*##-1- Configure the UART peripheral ######################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
/* UART configured as follows:
- Word Length = 8 Bits (7 data bit + 1 parity bit) :
BE CAREFUL : Program 7 data bits + 1 parity bit in PC HyperTerminal
- Stop Bit = One Stop bit
- Parity = ODD parity
- BaudRate = 9600 baud
- Hardware flow control disabled (RTS and CTS signals) */
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = 9600;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_ODD;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
if (HAL_UART_Init(&UartHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Start the transmission process #####################################*/
/* User start transmission data through "TxBuffer" buffer */
if (HAL_UART_Transmit_DMA(&UartHandle, (uint8_t *)aTxBuffer, TXBUFFERSIZE) != HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-3- Put UART peripheral in reception process ###########################*/
/* Any data received will be stored in "RxBuffer" buffer : the number max of
data received is 10 */
if (HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
/* Transfer error in reception process */
Error_Handler();
}
/*##-4- 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_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
{
}
/*##-5- Send the received Buffer ###########################################*/
if (HAL_UART_Transmit_DMA(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
/* Transfer error in transmission process */
Error_Handler();
}
/*##-6- 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_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
{
}
/* 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 the system clock to 72 MHz */
SystemClock_Config();
/* Configure LEDs */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED4);
/*##-1- Configure the TSC peripheral #######################################*/
TscHandle.Instance = TSCx;
TscHandle.Init.AcquisitionMode = TSC_ACQ_MODE_NORMAL;
TscHandle.Init.CTPulseHighLength = TSC_CTPH_1CYCLE;
TscHandle.Init.CTPulseLowLength = TSC_CTPL_1CYCLE;
TscHandle.Init.IODefaultMode = TSC_IODEF_OUT_PP_LOW;
TscHandle.Init.MaxCountInterrupt = ENABLE;
TscHandle.Init.MaxCountValue = TSC_MCV_16383;
TscHandle.Init.PulseGeneratorPrescaler = TSC_PG_PRESC_DIV64;
TscHandle.Init.SpreadSpectrum = DISABLE;
TscHandle.Init.SpreadSpectrumDeviation = 127;
TscHandle.Init.SpreadSpectrumPrescaler = TSC_SS_PRESC_DIV1;
TscHandle.Init.SynchroPinPolarity = TSC_SYNC_POL_FALL;
TscHandle.Init.ChannelIOs = 0; /* Not needed yet. Will be set with HAL_TSC_IOConfig() */
TscHandle.Init.SamplingIOs = 0; /* Not needed yet. Will be set with HAL_TSC_IOConfig() */
TscHandle.Init.ShieldIOs = 0; /* Not needed yet. Will be set with HAL_TSC_IOConfig() */
if (HAL_TSC_Init(&TscHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure the touch-sensing IOs ####################################*/
IoConfig.ChannelIOs = TSC_GROUP8_IO2; /* Start with the first channel */
IoConfig.SamplingIOs = (TSC_GROUP8_IO1 | TSC_GROUP8_IO1 | TSC_GROUP6_IO1);
IoConfig.ShieldIOs = TSC_GROUP6_IO2;
if (HAL_TSC_IOConfig(&TscHandle, &IoConfig) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-3- Discharge the touch-sensing IOs ####################################*/
HAL_TSC_IODischarge(&TscHandle, ENABLE);
HAL_Delay(1); /* 1 ms is more than enough to discharge all capacitors */
/*##-4- Start the acquisition process ######################################*/
if (HAL_TSC_Start_IT(&TscHandle) != HAL_OK)
{
/* Acquisition Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
/*Suspend Tick increment to prevent wakeup by Systick interrupt.
Otherwise the Systick interrupt will wake up the device within 1ms (HAL time base)*/
HAL_SuspendTick();
/* The acquisition process is now performed in the HAL_TSC_ConvCpltCallback() function */
HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
/* Resume Tick interrupt if disabled prior to sleep mode entry*/
HAL_ResumeTick();
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F3xx HAL library initialization:
- Configure the Flash prefetch
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure LED2 */
BSP_LED_Init(LED2);
/* Configure the system clock to 64 MHz */
SystemClock_Config();
/*##-1- Configure the TIM peripheral #######################################*/
/* -----------------------------------------------------------------------
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 / 2
=> TIM2CLK = HCLK = SystemCoreClock (Hz)
To get TIM2 counter clock at 10 KHz, the Prescaler is computed as following:
Prescaler = (TIM2CLK / TIM2 counter clock) - 1
Prescaler = (SystemCoreClock /10 KHz) - 1
Note:
SystemCoreClock variable holds HCLK frequency and is defined in system_stm32f3xx.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
----------------------------------------------------------------------- */
/* Compute the prescaler value to have TIMx counter clock equal to 10000 Hz */
uwPrescalerValue = (uint32_t)(SystemCoreClock / 10000) - 1;
/* Set TIMx instance */
TimHandle.Instance = TIMx;
/* Initialize TIMx peripheral as follows:
+ Period = 10000 - 1
+ Prescaler = (SystemCoreClock/10000) - 1
+ ClockDivision = 0
+ Counter direction = Up
*/
TimHandle.Init.Period = 10000 - 1;
TimHandle.Init.Prescaler = uwPrescalerValue;
TimHandle.Init.ClockDivision = 0;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
TimHandle.Init.RepetitionCounter = 0;
if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Start the TIM Base generation in interrupt mode ####################*/
/* Start Channel1 */
if (HAL_TIM_Base_Start_IT(&TimHandle) != 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 the system clock to 180 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)
{
/* This sample code shows how to convert an analog input and read the converted
data using DMA transfer.
To proceed, 4 steps are required: */
/* STM32L0xx HAL library initialization:
- Configure the Flash prefetch, Flash preread and Buffer caches
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 2 MHz */
SystemClock_Config();
/* Configure LED2 */
BSP_LED_Init(LED2);
/* ### - 1 - Initialize ADC peripheral #################################### */
AdcHandle.Instance = ADCx;
if (HAL_ADC_DeInit(&AdcHandle) != HAL_OK)
{
/* ADC de-initialization Error */
Error_Handler();
}
AdcHandle.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2; /* Synchronous clock mode, input ADC clock with prscaler 2 */
AdcHandle.Init.Resolution = ADC_RESOLUTION_12B; /* 12-bit resolution for converted data */
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT; /* Right-alignment for converted data */
AdcHandle.Init.ScanConvMode = ADC_SCAN_DIRECTION_FORWARD; /* Sequencer disabled (ADC conversion on only 1 channel: channel set on rank 1) */
AdcHandle.Init.EOCSelection = ADC_EOC_SINGLE_CONV; /* EOC flag picked-up to indicate conversion end */
AdcHandle.Init.LowPowerAutoPowerOff = DISABLE;
AdcHandle.Init.LowPowerFrequencyMode = DISABLE;
AdcHandle.Init.LowPowerAutoWait = DISABLE; /* Auto-delayed conversion feature disabled */
AdcHandle.Init.ContinuousConvMode = ENABLE; /* Continuous mode enabled (automatic conversion restart after each conversion) */
AdcHandle.Init.DiscontinuousConvMode = DISABLE; /* Parameter discarded because sequencer is disabled */
AdcHandle.Init.ExternalTrigConv = ADC_SOFTWARE_START; /* Software start to trig the 1st conversion manually, without external event */
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; /* Parameter discarded because software trigger chosen */
AdcHandle.Init.DMAContinuousRequests = ENABLE; /* ADC DMA continuous request to match with DMA circular mode */
AdcHandle.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN; /* DR register is overwritten with the last conversion result in case of overrun */
AdcHandle.Init.OversamplingMode = DISABLE; /* No oversampling */
AdcHandle.Init.SamplingTime = ADC_SAMPLETIME_7CYCLES_5;
/* Initialize ADC peripheral according to the passed parameters */
if (HAL_ADC_Init(&AdcHandle) != HAL_OK)
{
Error_Handler();
}
/* ### - 2 - Start calibration ############################################ */
if (HAL_ADCEx_Calibration_Start(&AdcHandle, ADC_SINGLE_ENDED) != HAL_OK)
{
Error_Handler();
}
/* ### - 3 - Channel configuration ######################################## */
sConfig.Channel = ADCx_CHANNEL; /* Channel to be converted */
sConfig.Rank = ADC_RANK_CHANNEL_NUMBER;
if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
{
Error_Handler();
}
/* ### - 4 - Start conversion in DMA mode ################################# */
if (HAL_ADC_Start_DMA(&AdcHandle,
(uint32_t *)aADCxConvertedData,
ADC_CONVERTED_DATA_BUFFER_SIZE
) != HAL_OK)
{
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 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();
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)
{
/* Initialize Key Button mounted on STM324x9I-EVAL board */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
/* Test if Key push-button on STM324x9I-EVAL Board is not pressed */
if (BSP_PB_GetState(BUTTON_KEY) != 0x00)
{ /* Key push-button not pressed: jump to user application */
/* Check if valid stack address (RAM address) then jump to user application */
if (((*(__IO uint32_t*)USER_FLASH_FIRST_PAGE_ADDRESS) & 0x2FFE0000 ) == 0x20000000)
{
/* Jump to user application */
JumpAddress = *(__IO uint32_t*) (USER_FLASH_FIRST_PAGE_ADDRESS + 4);
Jump_To_Application = (pFunction) JumpAddress;
/* Initialize user application's Stack Pointer */
__set_MSP(*(__IO uint32_t*) USER_FLASH_FIRST_PAGE_ADDRESS);
Jump_To_Application();
/* do nothing */
while(1);
}
else
{ /* Otherwise, do nothing */
/* LED3 (RED) ON to indicate bad software (when not valid stack address) */
BSP_LED_Init(LED3);
BSP_LED_On(LED3);
/* do nothing */
while(1);
}
}
/* Enter in IAP mode */
else
{
/* 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 the BSP */
BSP_Config();
/* Initilaize the LwIP stack */
lwip_init();
/* Configure the Network interface */
Netif_Config();
#ifdef USE_IAP_HTTP
/* Initialize the webserver module */
IAP_httpd_init();
#endif
#ifdef USE_IAP_TFTP
/* Initialize the TFTP server */
IAP_tftpd_init();
#endif
/* Notify user about the netwoek interface config */
User_notification(&gnetif);
/* Infinite loop */
while (1)
{
/* Read a received packet from the Ethernet buffers and send it
to the lwIP for handling */
ethernetif_input(&gnetif);
/* Handle timeouts */
sys_check_timeouts();
#ifdef USE_DHCP
/* handle periodic timers for LwIP */
DHCP_Periodic_Handle(&gnetif);
#endif
}
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F2xx 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 120 MHz */
SystemClock_Config();
/* Configure LED1 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/* Compute the prescaler value to have TIMx counter clock equal to 2 KHz */
uwPrescalerValue = ((SystemCoreClock /2) / 2000) - 1;
/*##-1- Configure the TIM peripheral #######################################*/
/* ---------------------------------------------------------------------------
TIM3 Configuration: Output Compare Active Mode:
In this example TIM3 input clock (TIM3CLK) is set to 2 * APB1 clock (PCLK1),
since APB1 prescaler is different from 1.
TIM3CLK = 2 * PCLK1
PCLK1 = HCLK / 4
=> TIM3CLK = HCLK / 2 = SystemCoreClock /2
To get TIM3 counter clock at 2 KHz, the prescaler is computed as follows:
Prescaler = (TIM3CLK / TIM3 counter clock) - 1
Prescaler = ((SystemCoreClock /2) /2 KHz) - 1
Generate 4 signals with 4 different delays:
TIM3_CH1 delay = uhCCR1_Val/TIM3 counter clock = 500 ms
TIM3_CH2 delay = uhCCR2_Val/TIM3 counter clock = 250 ms
TIM3_CH3 delay = uhCCR3_Val/TIM3 counter clock = 125 ms
TIM3_CH4 delay = uhCCR4_Val/TIM3 counter clock = 62.5 ms
Note:
SystemCoreClock variable holds HCLK frequency and is defined in system_stm32f2xx.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 TIMx peripheral as follow:
+ Prescaler = (SystemCoreClock/2)/2000
+ Period = 65535
+ ClockDivision = 0
+ Counter direction = Up
*/
TimHandle.Instance = TIMx;
TimHandle.Init.Period = 65535;
TimHandle.Init.Prescaler = uwPrescalerValue;
TimHandle.Init.ClockDivision = 0;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
if(HAL_TIM_OC_Init(&TimHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure the Output Compare channels ##############################*/
/* Common configuration for all channels */
sConfig.OCMode = TIM_OCMODE_ACTIVE;
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
/* Set the pulse (delay1) value for channel 1 */
sConfig.Pulse = PULSE1_VALUE;
if(HAL_TIM_OC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Set the pulse (delay2) value for channel 2 */
sConfig.Pulse = PULSE2_VALUE;
if(HAL_TIM_OC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Set the pulse (delay3) value for channel 3 */
sConfig.Pulse = PULSE3_VALUE;
if(HAL_TIM_OC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/* Set the pulse (delay4) value for channel 4 */
sConfig.Pulse = PULSE4_VALUE;
if(HAL_TIM_OC_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4) != HAL_OK)
{
/* Configuration Error */
Error_Handler();
}
/*##-3- Turn On LED1: use PG6 falling edge as reference ####################*/
/* Turn on LED1 */
BSP_LED_On(LED1);
/*##-4- Start signals generation ###########################################*/
/* Start channel 1 in Output compare mode */
if(HAL_TIM_OC_Start(&TimHandle, TIM_CHANNEL_1) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Start channel 2 in Output compare mode */
if(HAL_TIM_OC_Start(&TimHandle, TIM_CHANNEL_2) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Start channel 3 in Output compare mode */
if(HAL_TIM_OC_Start(&TimHandle, TIM_CHANNEL_3) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Start channel 4 in Output compare mode */
if(HAL_TIM_OC_Start(&TimHandle, TIM_CHANNEL_4) != HAL_OK)
{
/* Starting Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
int main(void) {
HAL_Init();
Nucleo_BSP_Init();
MX_TIM1_Init();
MX_TIM3_Init();
HAL_TIM_Encoder_Start(&htim3, TIM_CHANNEL_ALL);
HAL_TIM_OC_Start(&htim1, TIM_CHANNEL_1);
HAL_TIM_OC_Start(&htim1, TIM_CHANNEL_2);
cnt1 = __HAL_TIM_GET_COUNTER(&htim3);
tick = HAL_GetTick();
while (1) {
if (HAL_GetTick() - tick > 1000L) {
cnt2 = __HAL_TIM_GET_COUNTER(&htim3);
if (__HAL_TIM_IS_TIM_COUNTING_DOWN(&htim3)) {
if (cnt2 < cnt1) /* Check for counter underflow */
diff = cnt1 - cnt2;
else
diff = (65535 - cnt2) + cnt1;
} else {
if (cnt2 > cnt1) /* Check for counter overflow */
diff = cnt2 - cnt1;
else
diff = (65535 - cnt1) + cnt2;
}
sprintf(msg, "Difference: %d\r\n", diff);
HAL_UART_Transmit(&huart2, (uint8_t*) msg, strlen(msg), HAL_MAX_DELAY);
speed = ((diff / PULSES_PER_REVOLUTION) / 60);
/* If the first three bits of SMCR register are set to 0x3
* then the timer is set in X4 mode (TIM_ENCODERMODE_TI12)
* and we need to divide the pulses counter by two, because
* they include the pulses for both the channels */
if ((TIM3->SMCR & 0x3) == 0x3)
speed /= 2;
sprintf(msg, "Speed: %d RPM\r\n", speed);
HAL_UART_Transmit(&huart2, (uint8_t*) msg, strlen(msg), HAL_MAX_DELAY);
dir = __HAL_TIM_IS_TIM_COUNTING_DOWN(&htim3);
sprintf(msg, "Direction: %d\r\n", dir);
HAL_UART_Transmit(&huart2, (uint8_t*) msg, strlen(msg), HAL_MAX_DELAY);
tick = HAL_GetTick();
cnt1 = __HAL_TIM_GET_COUNTER(&htim3);
}
if (HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_RESET) {
/* Invert rotation by swapping CH1 and CH2 CCR value */
tim1_ch1_pulse = __HAL_TIM_GET_COMPARE(&htim1, TIM_CHANNEL_1);
tim1_ch2_pulse = __HAL_TIM_GET_COMPARE(&htim1, TIM_CHANNEL_2);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, tim1_ch2_pulse);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, tim1_ch1_pulse);
}
}
}
/**
* @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)
{
}
}
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_ADC_Init();
MX_DAC_Init();
MX_I2C1_Init();
MX_RTC_Init();
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
//int loopCnt = 0;
while (1)
{
Button_Function buttonFunction = checkButtonFunction();
if (buttonFunction == BTNFUNC_STATECHN)
{
wakeupSleepState = (wakeupSleepState == STATE_WAKEUP) ? STATE_SLEEP : STATE_WAKEUP;
}
if (buttonFunction == BTNFUNC_CAL)
{
setSensorDevPwr(DEV_PWR_ON);
getSnrDrvDacVal();
setSensorDevPwr(DEV_PWR_OFF);
wakeupSleepState = STATE_WAKEUP;
}
if (wakeupSleepState == STATE_WAKEUP)
{
uint16_t snrAdcVal = 0;
setBlueToothDevPwr(DEV_PWR_ON);
setSensorDevPwr(DEV_PWR_ON);
setSysWakeUpLed(LED_ON);
setSysStsLed(LED_OFF);
int snrDrvDacVal = readEEPROM32(EEPROM_ADDR_SNRDRVVAL);
if ((snrDrvDacVal < 1) || (snrDrvDacVal > 0xFFF))
{
getSnrDrvDacVal();
}
snrAdcVal = (uint16_t)dacOutAdcIn(snrDrvDacVal, ADC_CHANNEL_8);
if (snrAdcVal > SNR_PASS_THRESHOLD)
{
setTestPassLed(LED_ON);
setTestFailLed(LED_OFF);
}
else
{
setTestFailLed(LED_ON);
setTestPassLed(LED_OFF);
}
if (hi2c1.State == HAL_I2C_STATE_READY)
{
setBleSig(BLESIG_HI);
if (HAL_I2C_Slave_Transmit(&hi2c1, (uint8_t *)&snrAdcVal, 2, 3000) == HAL_OK)
{
setSysStsLed(LED_ON);
HAL_Delay(100);
setSysStsLed(LED_OFF);
HAL_Delay(100);
setSysStsLed(LED_ON);
HAL_Delay(100);
setSysStsLed(LED_OFF);
}
else
{
setSysStsLed(LED_ON);
HAL_Delay(300);
setSysStsLed(LED_OFF);
}
}
else
{
setSysWakeUpLed(LED_OFF);
HAL_Delay(100);
setSysWakeUpLed(LED_ON);
HAL_Delay(100);
setSysWakeUpLed(LED_OFF);
HAL_Delay(100);
setSysWakeUpLed(LED_ON);
HAL_Delay(100);
}
setTestFailLed(LED_OFF);
setTestPassLed(LED_OFF);
HAL_Delay(1000);
setBleSig(BLESIG_LO);
HAL_Delay(1000);
}
else
{
goSleep();
}
/*
loopCnt++;
if (loopCnt >= 2)
{
loopCnt = 0;
}
*/
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
int main(void)
{
/*Variable Declarations*/
uint8_t c;
uint16_t size = 0;
char ACK[7]="ACK\n";
char NACK[7]="NACK\n";
unsigned char status = 0;
/* 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); //Line used for enabling Gating Board 2
BSP_LED_Init(LED5); //Line used for enabling Gating Board 1
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.");
printf("\nDDS Channel Setup Complete");
//Initialize Timer for generating sync pulse and exposure counting
initializesync();
inituscounter();
printf("\nSync Pulse Initialized");
/* Initialize USB VCP */
TM_USB_VCP_Init();
printf("\nUSB Communication 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
//Start Pulsing VD_IN to start capture of frames
//startsyncpulse();
/* Infinite loop */
while (1)
{
/* USB configured OK, drivers OK */
if (TM_USB_VCP_GetStatus() == TM_USB_VCP_CONNECTED) {
BSP_LED_On(LED3); //Status - All Good!
//Only process USB when modulation not in progress
if (modulation_state==0){
/* If something arrived at VCP */
if(TM_USB_VCP_Getc(&c)==TM_USB_VCP_DATA_OK){
/* Return data back */
if (c=='M'){
//Add interrupt guard
__disable_irq();
printf("\n");
//Take 51 Bytes in after receiving M
size = 0;
while((TM_USB_VCP_Getc(&cmd[size]) == TM_USB_VCP_DATA_OK)&&(size < commandsize))
{
printf("%04x ",cmd[size]);
size++;
}
printf("%d",size);
status = parse_usb(cmd,size);
//Block checks is the parsing went correct
if (status==1){
TM_USB_VCP_Puts(ACK);
BSP_LED_On(LED6);
}
else{
TM_USB_VCP_Puts(NACK);
BSP_LED_Off(LED6);
}
}
else{
BSP_LED_Off(LED6);
TM_USB_VCP_Puts(NACK);
}
__enable_irq();
}}
} else {
/* USB not OK */
BSP_LED_Off(LED3);
}
}
}
/**
* @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 the system clock to 48 MHz */
SystemClock_Config();
/* Configure LED1, LED2 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
/*##-1- Configure the I2C peripheral #######################################*/
I2cHandle.Instance = I2Cx;
I2cHandle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
I2cHandle.Init.Timing = I2Cx_TIMING;
I2cHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
I2cHandle.Init.OwnAddress1 = 0;
I2cHandle.Init.OwnAddress2 = 0;
I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
I2cHandle.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
if (HAL_I2C_Init(&I2cHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* The board sends the message to EEPROM then reads it back */
/*##-2- Start writing process ##############################################*/
/* Initialize Remaining Bytes Value to TX Buffer Size */
Remaining_Bytes = TXBUFFERSIZE;
/* Initialize Memory address to 0 since EEPROM write will start from address 0 */
Memory_Address = 0;
/* Since page size is 4 bytes, the write procedure will be done in a loop */
while (Remaining_Bytes > 0)
{
/* Write 4 bytes */
if (HAL_I2C_Mem_Write_DMA(&I2cHandle, (uint16_t)I2C_ADDRESS, Memory_Address, I2C_MEMADD_SIZE_16BIT, (uint8_t *)(aTxBuffer + Memory_Address), 4) != HAL_OK)
{
/* Writing process Error */
Error_Handler();
}
/* Wait for the end of the transfer */
while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY)
{
}
/* Check if the EEPROM is ready for a new operation */
while (HAL_I2C_IsDeviceReady(&I2cHandle, I2C_ADDRESS, 20, 300) == HAL_TIMEOUT);
/* Wait for the end of the transfer */
while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY)
{
}
/* Update Remaining bytes and Memory Address values */
Remaining_Bytes -= 4;
Memory_Address += 4;
}
/*##-3- Start reading process ##############################################*/
if (HAL_I2C_Mem_Read_DMA(&I2cHandle, (uint16_t)I2C_ADDRESS, 0, I2C_MEMADD_SIZE_16BIT, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
{
/* Reading process Error */
Error_Handler();
}
/* Wait for the end of the transfer */
while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY)
{
}
/*##-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)
{
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 */
/* STM32F107xC 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();
/* Configure LED_GREEN and LED_RED */
BSP_LED_Init(LED_GREEN);
BSP_LED_Init(LED_RED);
/*##-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)
{
uint8_t lcd_status = LCD_OK;
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization: global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/* Initialize the SDRAM */
BSP_SDRAM_Init();
/* Initialize the LCD */
lcd_status = LCD_Init();
OnError_Handler(lcd_status != LCD_OK);
/* Initialize LTDC layer 0 iused for Hint */
LCD_LayertInit(0, LAYER0_ADDRESS);
BSP_LCD_SelectLayer(0);
HAL_DSI_LongWrite(&hdsi_eval, 0, DSI_DCS_LONG_PKT_WRITE, 4, OTM8009A_CMD_CASET, pColLeft);
HAL_DSI_LongWrite(&hdsi_eval, 0, DSI_DCS_LONG_PKT_WRITE, 4, OTM8009A_CMD_PASET, pPage);
/* Update pitch : the draw is done on the whole physical X Size */
HAL_LTDC_SetPitch(&hltdc_eval, BSP_LCD_GetXSize(), 0);
/* Display example brief */
LCD_BriefDisplay();
/* Show first image */
CopyPicture((uint32_t *)Images[ImageIndex++], (uint32_t *)LAYER0_ADDRESS, 240, 160, 320, 240);
pending_buffer = 0;
active_area = LEFT_AREA;
HAL_DSI_LongWrite(&hdsi_eval, 0, DSI_DCS_LONG_PKT_WRITE, 2, OTM8009A_CMD_WRTESCN, pSyncLeft);
/* Infinite loop */
while (1)
{
if(pending_buffer < 0)
{
CopyPicture((uint32_t *)Images[ImageIndex++], (uint32_t *)LAYER0_ADDRESS, 240, 160, 320, 240);
if(ImageIndex >= 2)
{
ImageIndex = 0;
}
pending_buffer = 1;
HAL_DSI_LongWrite(&hdsi_eval, 0, DSI_DCS_LONG_PKT_WRITE, 2, OTM8009A_CMD_WRTESCN, pSyncLeft);
}
/* Wait some time before switching to next image */
HAL_Delay(2000);
}
}
/**
* @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 LEDs, Push buttons and LCD available on EVAL board ************/
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure push Buttons */
/* Key button used for Pause/Resume */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
/* Wakeup button used for Volume High */
BSP_PB_Init(BUTTON_WAKEUP, BUTTON_MODE_GPIO);
/* Tamper button used for Volume Low */
BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_GPIO);
/* Initialize the LCD */
BSP_LCD_Init();
/* Display message on EVAL LCD **********************************************/
/* Clear the LCD */
BSP_LCD_Clear(LCD_COLOR_BLUE);
/* Set the LCD Back Color */
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
/* Set the LCD Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAtLine(0, (uint8_t *)MESSAGE1);
BSP_LCD_DisplayStringAtLine(1, (uint8_t *)MESSAGE2);
BSP_LCD_DisplayStringAtLine(2, (uint8_t *)MESSAGE3);
/* Turn On LEDs available on EVAL *******************************************/
BSP_LED_On(LED1);
BSP_LED_On(LED2);
BSP_LED_On(LED3);
BSP_LED_On(LED4);
/* Initialize the Audio codec and all related peripherals (I2S, I2C, IOExpander, IOs...) */
if(AUDIO_Init() == AUDIO_ERROR_NONE)
{
BSP_LCD_DisplayStringAtLine(3, (uint8_t *)"====================");
BSP_LCD_DisplayStringAtLine(4, (uint8_t *)"Key : Play/Pause ");
BSP_LCD_DisplayStringAtLine(5, (uint8_t *)"Tamper: Vol+/Headph");
BSP_LCD_DisplayStringAtLine(6, (uint8_t *)"Wakeup: Vol-/Spkr ");
BSP_LCD_DisplayStringAtLine(7, (uint8_t *)"====================");
BSP_LCD_DisplayStringAtLine(8, (uint8_t *)" AUDIO CODEC OK ");
}
else
{
BSP_LCD_DisplayStringAtLine(4, (uint8_t *)" AUDIO CODEC FAIL ");
BSP_LCD_DisplayStringAtLine(5, (uint8_t *)" Try to reset board ");
}
/*
Start playing the file from a circular buffer, once the DMA is enabled, it is
always in running state. Application has to fill the buffer with the audio data
using Transfer complete and/or half transfer complete interrupts callbacks
(EVAL_AUDIO_TransferComplete_CallBack() or EVAL_AUDIO_HalfTransfer_CallBack()...
*/
AUDIO_Start();
/* Display the state on the screen */
BSP_LCD_DisplayStringAtLine(8, (uint8_t *)" PLAYING ");
/* Infinite loop */
while (1)
{
/* Check on the Pause/Resume button */
if(BSP_PB_GetState(BUTTON_KEY) == RESET)
{
/* Wait to avoid rebound */
while (BSP_PB_GetState(BUTTON_KEY) == RESET);
if(uwCommand == AUDIO_PAUSE)
{
BSP_AUDIO_OUT_Pause();
/* Display the current state of the player */
BSP_LCD_DisplayStringAtLine(8, (uint8_t *)" PAUSED ");
/* Next time Resume command should be processed */
uwCommand = AUDIO_RESUME;
/* Push buttons will be used to switch between Speaker and Headphone modes */
uwSpHpSwitch = 1;
}
else
{
BSP_AUDIO_OUT_Resume();
/* Display the current state of the player */
BSP_LCD_DisplayStringAtLine(8, (uint8_t *)" PLAYING ");
/* Next time Pause command should be processed */
uwCommand = AUDIO_PAUSE;
/* Push buttons will be used to control volume level */
uwSpHpSwitch = 0;
}
}
/* Check on the Volume high button */
if (BSP_PB_GetState(BUTTON_WAKEUP) != RESET)
{
/* Check if the current state is paused (push buttons are used for volume control or for
speaker/headphone mode switching) */
if (uwSpHpSwitch)
{
/* Set output to Speaker */
BSP_AUDIO_OUT_SetOutputMode(OUTPUT_DEVICE_SPEAKER);
/* Display the current state of the player */
BSP_LCD_DisplayStringAtLine(9, (uint8_t *)" SPEAKER ");
}
else
{
/* Wait to avoid rebound */
while (BSP_PB_GetState(BUTTON_WAKEUP) != RESET);
/* Decrease volume by 5% */
if (uwVolume > 5)
uwVolume -= 5;
else
uwVolume = 0;
/* Apply the new volume to the codec */
BSP_AUDIO_OUT_SetVolume(uwVolume);
BSP_LCD_DisplayStringAtLine(9, (uint8_t *)" VOL: - ");
}
}
/* Check on the Volume high button */
if (BSP_PB_GetState(BUTTON_TAMPER) == RESET)
{
/* Check if the current state is paused (push buttons are used for volume control or for
speaker/headphone mode switching) */
if (uwSpHpSwitch)
{
/* Set output to Headphone */
BSP_AUDIO_OUT_SetOutputMode(OUTPUT_DEVICE_HEADPHONE);
/* Display the current state of the player */
BSP_LCD_DisplayStringAtLine(9, (uint8_t *)" HEADPHONE ");
}
else
{
/* Wait to avoid rebound */
while (BSP_PB_GetState(BUTTON_TAMPER) == RESET);
/* Increase volume by 5% */
if (uwVolume < 95)
uwVolume += 5;
else
uwVolume = 100;
/* Apply the new volume to the codec */
BSP_AUDIO_OUT_SetVolume(uwVolume);
BSP_LCD_DisplayStringAtLine(9, (uint8_t *)" VOL: + ");
}
}
/* Toggle LED3 */
BSP_LED_Toggle(LED3);
/* Insert 100 ms delay */
HAL_Delay(100);
/* Toggle LED2 */
BSP_LED_Toggle(LED2);
/* Insert 100 ms delay */
HAL_Delay(100);
}
}
// This function is called after RAM initialization and before main.
void mbed_sdk_init() {
// Update the SystemCoreClock variable.
SystemCoreClockUpdate();
// Need to restart HAL driver after the RAM is initialized
HAL_Init();
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F0xx HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Low Level Initialization
*/
HAL_Init();
/* Configure LED3 and LED4 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure the system clock to 48 MHz */
SystemClock_Config();
/*##-1- Configure the UART peripheral ######################################*/
/* Put the USART peripheral in the Asynchronous mode (UART Mode) */
/* UART configured as follows:
- Word Length = 8 Bits
- Stop Bit = One Stop bit
- Parity = None
- BaudRate = 9600 baud
- Hardware flow control disabled (RTS and CTS signals) */
UartHandle.Instance = USARTx;
UartHandle.Init.BaudRate = 9600;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_NONE;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if(HAL_UART_DeInit(&UartHandle) != HAL_OK)
{
Error_Handler();
}
if(HAL_UART_Init(&UartHandle) != HAL_OK)
{
Error_Handler();
}
#ifdef TRANSMITTER_BOARD
/* Configure User push-button in Interrupt mode */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
/* Wait for User push-button press before starting the Communication.
In the meantime, LED4 is blinking */
while(UserButtonStatus == 0)
{
/* Toggle LED4*/
BSP_LED_Toggle(LED4);
HAL_Delay(100);
}
BSP_LED_Off(LED4);
/* The board sends the message and expects to receive it back */
/*##-2- Start the transmission process #####################################*/
/* While the UART in reception process, user can transmit data through
"aTxBuffer" buffer */
if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 5000)!= HAL_OK)
{
Error_Handler();
}
/* Turn LED3 on: Transfer in transmission process is correct */
BSP_LED_On(LED3);
/*##-3- Put UART peripheral in reception process ###########################*/
if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE, 5000) != HAL_OK)
{
Error_Handler();
}
#else
/* The board receives the message and sends it back */
/*##-2- Put UART peripheral in reception process ###########################*/
if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE, 0x1FFFFFF) != HAL_OK)
{
Error_Handler();
}
/* Turn LED3 on: Transfer in reception process is correct */
BSP_LED_On(LED3);
/*##-3- Start the transmission process #####################################*/
/* While the UART in reception process, user can transmit data through
"aTxBuffer" buffer */
if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 5000)!= HAL_OK)
{
Error_Handler();
}
#endif /* TRANSMITTER_BOARD */
/*##-4- Compare the sent and received buffers ##############################*/
if(Buffercmp((uint8_t*)aTxBuffer,(uint8_t*)aRxBuffer,RXBUFFERSIZE))
{
Error_Handler();
}
/* Turn on LED4 if test passes then enter infinite loop */
BSP_LED_On(LED4);
/* 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
- 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 LED1, LED2 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
/*##-1- Configure the CRYP peripheral ######################################*/
/* Set the CRYP parameters */
CrypHandle.Instance = CRYP;
CrypHandle.Init.DataType = CRYP_DATATYPE_8B;
CrypHandle.Init.KeySize = CRYP_KEYSIZE_128B;
CrypHandle.Init.pKey = aAES128Key;
CrypHandle.Init.pInitVect = aNonce;
CrypHandle.Init.IVSize = uwNonceSize;
CrypHandle.Init.Header = aHeaderMessage;
CrypHandle.Init.HeaderSize = 16;
CrypHandle.Init.TagSize = 6;
CrypHandle.Init.pScratch = aHBuffer;
if(HAL_CRYP_Init(&CrypHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Start the AES Encryption in CCM chaining mode ######################*/
if(HAL_CRYPEx_AESCCM_Encrypt(&CrypHandle, aPlaintext, PLAINTEXT_SIZE, aOutputText, 0xFF) != HAL_OK)
{
/* Encryption Error */
Error_Handler();
}
/*##-3- Compute the authentication TAG for AES CCM mode ####################*/
if(HAL_CRYPEx_AESCCM_Finish(&CrypHandle, aMAC, 0xFF) != HAL_OK)
{
/* TAG Error */
Error_Handler();
}
/*##-4- Compare the encrypted text and the aMAC with the expected ones #####*/
if( (memcmp(aOutputText, aExpectedCyphertext, PLAINTEXT_SIZE) != 0) || (memcmp(aMAC, aExpectedMAC, MAC_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)
{
}
}