int main(void) {
char msg[20];
uint16_t rawValues[3];
float temp;
HAL_Init();
Nucleo_BSP_Init();
/* Initialize all configured peripherals */
MX_TIM1_Init();
MX_ADC1_Init();
HAL_ADCEx_Calibration_Start(&hadc1);
HAL_TIM_Base_Start(&htim1);
HAL_ADC_Start_DMA(&hadc1, (uint32_t*)rawValues, 1);
while(1) {
while(!convCompleted);
for(uint8_t i = 0; i < 1; i++) {
temp = ((float)rawValues[i]) / 4095 * 3300;
temp = ((temp - 1430.0) / 4.3) + 25;
sprintf(msg, "rawValue %d: %hu\r\n", i, rawValues[i]);
HAL_UART_Transmit(&huart2, (uint8_t*) msg, strlen(msg), HAL_MAX_DELAY);
sprintf(msg, "Temperature %d: %f\r\n",i, temp);
HAL_UART_Transmit(&huart2, (uint8_t*) msg, strlen(msg), HAL_MAX_DELAY);
}
convCompleted = 0;
}
}
void StartPeriphTimers()
{
/* Стартуем высокоточный таймер (TIM2+TIM3) для контроля временных задержек низкоуровневых функций */
HAL_TIM_Base_Start(&htim2);
HAL_TIM_Base_Start(&htim3);
/* Стартуем таймер для контроля процессов управления микросхемой CMX7262 */
HAL_TIM_Base_Start(&htim5);
}
/// \method read_timed(buf, timer)
///
/// Read analog values into `buf` at a rate set by the `timer` object.
///
/// `buf` can be bytearray or array.array for example. The ADC values have
/// 12-bit resolution and are stored directly into `buf` if its element size is
/// 16 bits or greater. If `buf` has only 8-bit elements (eg a bytearray) then
/// the sample resolution will be reduced to 8 bits.
///
/// `timer` should be a Timer object, and a sample is read each time the timer
/// triggers. The timer must already be initialised and running at the desired
/// sampling frequency.
///
/// To support previous behaviour of this function, `timer` can also be an
/// integer which specifies the frequency (in Hz) to sample at. In this case
/// Timer(6) will be automatically configured to run at the given frequency.
///
/// Example using a Timer object (preferred way):
///
/// adc = pyb.ADC(pyb.Pin.board.X19) # create an ADC on pin X19
/// tim = pyb.Timer(6, freq=10) # create a timer running at 10Hz
/// buf = bytearray(100) # creat a buffer to store the samples
/// adc.read_timed(buf, tim) # sample 100 values, taking 10s
///
/// Example using an integer for the frequency:
///
/// adc = pyb.ADC(pyb.Pin.board.X19) # create an ADC on pin X19
/// buf = bytearray(100) # create a buffer of 100 bytes
/// adc.read_timed(buf, 10) # read analog values into buf at 10Hz
/// # this will take 10 seconds to finish
/// for val in buf: # loop over all values
/// print(val) # print the value out
///
/// This function does not allocate any memory.
STATIC mp_obj_t adc_read_timed(mp_obj_t self_in, mp_obj_t buf_in, mp_obj_t freq_in) {
pyb_obj_adc_t *self = self_in;
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_WRITE);
size_t typesize = mp_binary_get_size('@', bufinfo.typecode, NULL);
TIM_HandleTypeDef *tim;
#if defined(TIM6)
if (mp_obj_is_integer(freq_in)) {
// freq in Hz given so init TIM6 (legacy behaviour)
tim = timer_tim6_init(mp_obj_get_int(freq_in));
HAL_TIM_Base_Start(tim);
} else
#endif
{
// use the supplied timer object as the sampling time base
tim = pyb_timer_get_handle(freq_in);
}
// configure the ADC channel
adc_config_channel(&self->handle, self->channel);
// This uses the timer in polling mode to do the sampling
// TODO use DMA
uint nelems = bufinfo.len / typesize;
for (uint index = 0; index < nelems; index++) {
// Wait for the timer to trigger so we sample at the correct frequency
while (__HAL_TIM_GET_FLAG(tim, TIM_FLAG_UPDATE) == RESET) {
}
__HAL_TIM_CLEAR_FLAG(tim, TIM_FLAG_UPDATE);
if (index == 0) {
// for the first sample we need to turn the ADC on
HAL_ADC_Start(&self->handle);
} else {
// for subsequent samples we can just set the "start sample" bit
#if defined(STM32F4) || defined(STM32F7)
ADCx->CR2 |= (uint32_t)ADC_CR2_SWSTART;
#elif defined(STM32L4)
SET_BIT(ADCx->CR, ADC_CR_ADSTART);
#else
#error Unsupported processor
#endif
}
// wait for sample to complete
#define READ_TIMED_TIMEOUT (10) // in ms
adc_wait_for_eoc_or_timeout(READ_TIMED_TIMEOUT);
// read value
uint value = ADCx->DR;
// store value in buffer
if (typesize == 1) {
value >>= 4;
}
mp_binary_set_val_array_from_int(bufinfo.typecode, bufinfo.buf, index, value);
}
void us_ticker_init(void)
{
if (us_ticker_inited) return;
us_ticker_inited = 1;
// Enable timer clock
TIM_MST_RCC;
// Configure time base
TimMasterHandle.Instance = TIM_MST;
TimMasterHandle.Init.Period = 0xFFFF;
TimMasterHandle.Init.Prescaler = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick
TimMasterHandle.Init.ClockDivision = 0;
TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_Base_Init(&TimMasterHandle);
// Configure interrupts
__HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_UPDATE);
// Update interrupt used for 32-bit counter
NVIC_SetVector(TIM_MST_UP_IRQ, (uint32_t)tim_update_irq_handler);
NVIC_EnableIRQ(TIM_MST_UP_IRQ);
// Output compare interrupt used for timeout feature
NVIC_SetVector(TIM_MST_OC_IRQ, (uint32_t)tim_oc_irq_handler);
NVIC_EnableIRQ(TIM_MST_OC_IRQ);
// Enable timer
HAL_TIM_Base_Start(&TimMasterHandle);
}
/**
* @brief Start audio recording
* @param pbuf Main buffer pointer for the recorded data storing
* @param size Current size of the recorded buffer
* @retval AUDIO_OK if correct communication, else wrong communication
*/
uint8_t BSP_AUDIO_IN_Record(uint16_t* pbuf, uint32_t size)
{
uint32_t ret = AUDIO_OK;
TIM_MasterConfigTypeDef master_config = {0};
if (HAL_ADC_Start_DMA(&hAudioInAdc, (uint32_t*)pbuf, size) == HAL_OK)
{
master_config.MasterOutputTrigger = TIM_TRGO_UPDATE;
master_config.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&hAudioInTim3, &master_config);
/* Start the time base triggering the ADC */
if (HAL_TIM_Base_Start(&hAudioInTim3) != HAL_OK)
{
ret = AUDIO_ERROR;
}
}
else
{
ret = AUDIO_ERROR;
}
return ret;
}
/// \method read_timed(buf, freq)
/// Read analog values into the given buffer at the given frequency. Buffer
/// can be bytearray or array.array for example. If a buffer with 8-bit elements
/// is used, sample resolution will be reduced to 8 bits.
///
/// Example:
///
/// adc = pyb.ADC(pyb.Pin.board.X19) # create an ADC on pin X19
/// buf = bytearray(100) # create a buffer of 100 bytes
/// adc.read_timed(buf, 10) # read analog values into buf at 10Hz
/// # this will take 10 seconds to finish
/// for val in buf: # loop over all values
/// print(val) # print the value out
///
/// This function does not allocate any memory.
STATIC mp_obj_t adc_read_timed(mp_obj_t self_in, mp_obj_t buf_in, mp_obj_t freq_in) {
pyb_obj_adc_t *self = self_in;
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_WRITE);
int typesize = mp_binary_get_size('@', bufinfo.typecode, NULL);
// Init TIM6 at the required frequency (in Hz)
timer_tim6_init(mp_obj_get_int(freq_in));
// Start timer
HAL_TIM_Base_Start(&TIM6_Handle);
// This uses the timer in polling mode to do the sampling
// We could use DMA, but then we can't convert the values correctly for the buffer
adc_config_channel(self);
for (uint index = 0; index < bufinfo.len; index++) {
// Wait for the timer to trigger
while (__HAL_TIM_GET_FLAG(&TIM6_Handle, TIM_FLAG_UPDATE) == RESET) {
}
__HAL_TIM_CLEAR_FLAG(&TIM6_Handle, TIM_FLAG_UPDATE);
uint value = adc_read_channel(&self->handle);
if (typesize == 1) {
value >>= 4;
}
mp_binary_set_val_array_from_int(bufinfo.typecode, bufinfo.buf, index, value);
}
uint16_t ADC_Get_Pulse(void)
{
uint16_t adc_value;
uint16_t adc_valuetest=0;
ADC_Config_CH2();
if (HAL_ADCEx_Calibration_Start(&AdcHandle) != HAL_OK)
{
/* Calibration Error */
Error_Handler();
}
#if defined(ADC_TRIGGER_FROM_TIMER)
/* Configure the TIM peripheral */
TIM_Config();
#endif /* ADC_TRIGGER_FROM_TIMER */
/*## Enable peripherals ####################################################*/
#if defined(ADC_TRIGGER_FROM_TIMER)
/* Timer enable */
if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
{
/* Counter Enable Error */
Error_Handler();
}
#endif /* ADC_TRIGGER_FROM_TIMER */
/* Note: This example, on some other STM32 boards, is performing */
/* DAC signal generation here. */
/* On STM32F103RB-Nucleo, the device has no DAC available, */
/* therefore analog signal must be supplied externally. */
/*## Start ADC conversions #################################################*/
/* Start ADC conversion on regular group with transfer by DMA */
// if (HAL_ADC_Start_DMA(&AdcHandle,
// (uint32_t *)aADCxConvertedValues,
// ADCCONVERTEDVALUES_BUFFER_SIZE
// ) != HAL_OK)
// {
// /* Start Error */
// Error_Handler();
// }
if (HAL_ADC_Start(&AdcHandle) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
if (HAL_ADC_PollForConversion(&AdcHandle,10) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
adc_value= HAL_ADC_GetValue(&AdcHandle);
return(adc_value);
}
/**
* @brief TIM6 Configuration
* @note TIM6 configuration is based on APB1 frequency
* @note TIM6 Update event occurs each TIM6CLK/256
* @param None
* @retval None
*/
void TIM6_Config(void)
{
static TIM_HandleTypeDef htim;
TIM_MasterConfigTypeDef sMasterConfig;
/*##-1- Configure the TIM peripheral #######################################*/
/* Time base configuration */
htim.Instance = TIM6;
htim.Init.Period = 0x7FF;
htim.Init.Prescaler = 0;
htim.Init.ClockDivision = 0;
htim.Init.CounterMode = TIM_COUNTERMODE_UP;
htim.Init.RepetitionCounter = 0;
HAL_TIM_Base_Init(&htim);
/* TIM6 TRGO selection */
sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim, &sMasterConfig);
/*##-2- Enable TIM peripheral counter ######################################*/
HAL_TIM_Base_Start(&htim);
}
static void acquisition_start(void)
{
HAL_DAC_Start_DMA(&hdac, DAC_CHANNEL_1, (uint32_t*)&wave_buff, WAVE_BUFF_LEN, DAC_ALIGN_12B_R);
HAL_ADC_Start_IT(&hadc2);
HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&mic_buff, WAVE_BUFF_LEN);
HAL_TIM_Base_Start(&htim2);
HAL_TIM_Base_Start_IT(&htim3);
}
// Reconfigure the HAL tick using a standard timer instead of systick.
HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority) {
// Enable timer clock
TIM_MST_RCC;
// Reset timer
TIM_MST_RESET_ON;
TIM_MST_RESET_OFF;
// Update the SystemCoreClock variable
SystemCoreClockUpdate();
// Configure time base
TimMasterHandle.Instance = TIM_MST;
TimMasterHandle.Init.Period = 0xFFFF;
TimMasterHandle.Init.Prescaler = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 us tick
TimMasterHandle.Init.ClockDivision = 0;
TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_Base_Init(&TimMasterHandle);
// Configure output compare channel 1 for mbed timeout (enabled later when used)
HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_1);
// Configure output compare channel 2 for HAL tick
HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_2);
PreviousVal = __HAL_TIM_GetCounter(&TimMasterHandle);
__HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_2, PreviousVal + HAL_TICK_DELAY);
// Configure interrupts
// Update interrupt used for 32-bit counter
// Output compare channel 1 interrupt for mbed timeout
// Output compare channel 2 interrupt for HAL tick
NVIC_SetVector(TIM_MST_UP_IRQ, (uint32_t)timer_update_irq_handler);
NVIC_EnableIRQ(TIM_MST_UP_IRQ);
NVIC_SetPriority(TIM_MST_UP_IRQ, 0);
NVIC_SetVector(TIM_MST_OC_IRQ, (uint32_t)timer_oc_irq_handler);
NVIC_EnableIRQ(TIM_MST_OC_IRQ);
NVIC_SetPriority(TIM_MST_OC_IRQ, 1);
// Enable interrupts
__HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_UPDATE); // For 32-bit counter
__HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC2); // For HAL tick
// Enable timer
HAL_TIM_Base_Start(&TimMasterHandle);
#if 0 // For DEBUG only
__GPIOB_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Pin = GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
#endif
return HAL_OK;
}
void Timer_Init(void)
{
#ifndef _MS_VS
__TIM6_CLK_ENABLE(); // Для отсчёта миллисекунд
__TIM2_CLK_ENABLE(); // Для тиков
__TIM5_CLK_ENABLE();
#endif
HAL_TIM_Base_Init((TIM_HandleTypeDef*)&handleTIM6);
HAL_TIM_Base_Start_IT((TIM_HandleTypeDef*)&handleTIM6);
TIM_HandleTypeDef handleTIM2 =
{
TIM2,
{
0,
TIM_COUNTERMODE_UP,
0xffffffff,
TIM_CLOCKDIVISION_DIV4
}
};
HAL_TIM_Base_Init((TIM_HandleTypeDef*)&handleTIM2);
HAL_TIM_Base_Start((TIM_HandleTypeDef*)&handleTIM2);
TIM_HandleTypeDef handleTIM5 =
{
TIM5,
{
8999, // WARN Так и не разобрался, как настроить таймер на 1мс. При 8999 период счета - 10мс.
TIM_COUNTERMODE_UP,
0xffffffff,
TIM_CLOCKDIVISION_DIV1
}
};
HAL_TIM_Base_Init((TIM_HandleTypeDef*)&handleTIM5);
HAL_TIM_Base_Start((TIM_HandleTypeDef*)&handleTIM5);
}
void threewire_tim_set_prescaler(t_hydra_console *con)
{
mode_config_proto_t* proto = &con->mode->proto;
HAL_TIM_Base_Stop(&htim);
HAL_TIM_Base_DeInit(&htim);
htim.Init.Prescaler = (THREEWIRE_MAX_FREQ/proto->config.rawwire.dev_speed) - 1;
HAL_TIM_Base_Init(&htim);
TIM4->SR &= ~TIM_SR_UIF; //clear overflow flag
HAL_TIM_Base_Start(&htim);
}
void TickTock_Init(void)
{
__TIM5_CLK_ENABLE();
TIM_Handle.Instance = TIM5;
TIM_Handle.Init.Period = 0xFFFFFFFF;
TIM_Handle.Init.Prescaler = 83;
TIM_Handle.Init.ClockDivision = 0;
TIM_Handle.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_Base_Init(&TIM_Handle);
HAL_TIM_Base_Start(&TIM_Handle);
}
/// \method read_timed(buf, freq)
/// Read analog values into the given buffer at the given frequency. Buffer
/// can be bytearray or array.array for example. If a buffer with 8-bit elements
/// is used, sample resolution will be reduced to 8 bits.
///
/// Example:
///
/// adc = pyb.ADC(pyb.Pin.board.X19) # create an ADC on pin X19
/// buf = bytearray(100) # create a buffer of 100 bytes
/// adc.read_timed(buf, 10) # read analog values into buf at 10Hz
/// # this will take 10 seconds to finish
/// for val in buf: # loop over all values
/// print(val) # print the value out
///
/// This function does not allocate any memory.
STATIC mp_obj_t adc_read_timed(mp_obj_t self_in, mp_obj_t buf_in, mp_obj_t freq_in) {
pyb_obj_adc_t *self = self_in;
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_WRITE);
int typesize = mp_binary_get_size('@', bufinfo.typecode, NULL);
// Init TIM6 at the required frequency (in Hz)
timer_tim6_init(mp_obj_get_int(freq_in));
// Start timer
HAL_TIM_Base_Start(&TIM6_Handle);
// configure the ADC channel
adc_config_channel(self);
// This uses the timer in polling mode to do the sampling
// TODO use DMA
uint nelems = bufinfo.len / typesize;
for (uint index = 0; index < nelems; index++) {
// Wait for the timer to trigger so we sample at the correct frequency
while (__HAL_TIM_GET_FLAG(&TIM6_Handle, TIM_FLAG_UPDATE) == RESET) {
}
__HAL_TIM_CLEAR_FLAG(&TIM6_Handle, TIM_FLAG_UPDATE);
if (index == 0) {
// for the first sample we need to turn the ADC on
HAL_ADC_Start(&self->handle);
} else {
// for subsequent samples we can just set the "start sample" bit
ADCx->CR2 |= (uint32_t)ADC_CR2_SWSTART;
}
// wait for sample to complete
uint32_t tickstart = HAL_GetTick();
while ((ADCx->SR & ADC_FLAG_EOC) != ADC_FLAG_EOC) {
#define READ_TIMED_TIMEOUT (10) // in ms
if (((HAL_GetTick() - tickstart ) > READ_TIMED_TIMEOUT)) {
break; // timeout
}
}
// read value
uint value = ADCx->DR;
// store value in buffer
if (typesize == 1) {
value >>= 4;
}
mp_binary_set_val_array_from_int(bufinfo.typecode, bufinfo.buf, index, value);
}
STATIC void TIM6_Config(uint freq) {
// Init TIM6 at the required frequency (in Hz)
timer_tim6_init(freq);
// TIM6 TRGO selection
TIM_MasterConfigTypeDef config;
config.MasterOutputTrigger = TIM_TRGO_UPDATE;
config.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&TIM6_Handle, &config);
// TIM6 start counter
HAL_TIM_Base_Start(&TIM6_Handle);
}
/**
* @brief This function Resumes the audio file stream.
* @retval AUDIO_OK if correct communication, else wrong communication
*/
uint8_t BSP_AUDIO_IN_Resume(void)
{
uint32_t ret = AUDIO_OK;
/* Start the time base triggering the ADC */
if (HAL_TIM_Base_Start(&hAudioInTim3) != HAL_OK)
{
ret = AUDIO_ERROR;
}
/* Return AUDIO_OK if all operations are OK */
return ret;
}
void Ultrasonic_Echo(char high){
if (Ultrasonic.status == USS_IDLE) return;
if (high) { //超声波开始
HAL_TIM_Base_Start(&htim_sonar);
Ultrasonic.status = USS_TIMING;
} else { //超声波结束
HAL_TIM_Base_Stop(&htim_sonar);
US_UPDATE(htim_sonar.Instance->CNT / Ultrasonic_SpeedFactor);
if (Ultrasonic.callback)
(*Ultrasonic.callback)();
Ultrasonic.status = USS_IDLE;
}
}
//Enables timer and setup 1ms periodic interrupt.
void bl_Init(void){
TIM_ENPERCLK();
Tmr.Instance = TIM_INSTANCE;
Tmr.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
Tmr.Init.CounterMode = TIM_COUNTERMODE_UP;
Tmr.Init.Period = TIM_CNTPERMS - 1;
Tmr.Init.Prescaler = TIM_PRESC - 1;
HAL_TIM_Base_Init(&Tmr);
HAL_NVIC_SetPriority(TIM_IRQN, 3, 3);
HAL_NVIC_EnableIRQ(TIM_IRQN);
__HAL_TIM_ENABLE_IT(&Tmr, TIM_IT_UPDATE);
HAL_TIM_Base_Start(&Tmr);
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* Enable the CPU Cache */
CPU_CACHE_Enable();
/* STM32F7xx HAL library initialization:
- Configure the Flash ART accelerator on ITCM interface
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 216 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- TIM Peripheral Configuration ######################################*/
TIM_Config();
/*##-2- Configure the ADC peripheral ######################################*/
ADC_Config();
/*##-4- Start the conversion process and enable interrupt ##################*/
if (HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
__HAL_RCC_DAC_CLK_ENABLE();
/*##-3- TIM counter enable ################################################*/
if (HAL_TIM_Base_Start(&htim) != HAL_OK)
{
/* Counter Enable Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
void POLOLU_MOTOR_Init(MOTOR_InitTypeDef *motor)
{
assert_param(IS_GPIO_PIN(motor->PinIn1));
assert_param(IS_GPIO_PIN(motor->PinIn2));
if (motor->htimIn1 != NULL)
{
HAL_TIM_Base_Start(motor->htimIn1);
}
if (motor->htimIn2 != NULL)
{
HAL_TIM_Base_Start(motor->htimIn2);
}
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Pin = motor->PinIn1 ;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(motor->GPIOxIn1, &GPIO_InitStruct);
GPIO_InitStruct.Pin = motor->PinIn2;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(motor->GPIOxIn2, &GPIO_InitStruct);
}
void threewire_tim_init(t_hydra_console *con)
{
mode_config_proto_t* proto = &con->mode->proto;
htim.Instance = TIM4;
htim.Init.Period = 42 - 1;
htim.Init.Prescaler = (THREEWIRE_MAX_FREQ/proto->config.rawwire.dev_speed) - 1;
htim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_Base_MspInit(&htim);
__TIM4_CLK_ENABLE();
HAL_TIM_Base_Init(&htim);
TIM4->SR &= ~TIM_SR_UIF; //clear overflow flag
HAL_TIM_Base_Start(&htim);
}
/**
* @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();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- TIM Peripheral Configuration ######################################*/
TIM_Config();
/*##-2- Configure the ADC peripheral ######################################*/
ADC_Config();
/*##-4- Start the conversion process and enable interrupt ##################*/
if (HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/*##-3- TIM counter enable ################################################*/
if (HAL_TIM_Base_Start(&htim) != HAL_OK)
{
/* Counter Enable Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
// TIM3 is set-up for the USB CDC interface
void timer_tim3_init(void) {
// set up the timer for USBD CDC
__TIM3_CLK_ENABLE();
TIM3_Handle.Instance = TIM3;
TIM3_Handle.Init.Period = (USBD_CDC_POLLING_INTERVAL*1000) - 1; // TIM3 fires every USBD_CDC_POLLING_INTERVAL ms
TIM3_Handle.Init.Prescaler = 84-1; // for System clock at 168MHz, TIM3 runs at 1MHz
TIM3_Handle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
TIM3_Handle.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_Base_Init(&TIM3_Handle);
HAL_NVIC_SetPriority(TIM3_IRQn, 6, 0);
HAL_NVIC_EnableIRQ(TIM3_IRQn);
if (HAL_TIM_Base_Start(&TIM3_Handle) != HAL_OK) {
/* Starting Error */
}
}
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_I2C1_Init();
MX_TIM1_Init();
MX_TIM3_Init();
MX_ADC1_Init();
MX_TIM2_Init();
/* USER CODE BEGIN 2 */
//Start PWM
HAL_TIM_Base_Start(&htim1);
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_ALL);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
HAL_Delay(100);
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
// Reconfigure the HAL tick using a standard timer instead of systick.
HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority) {
// Enable timer clock
TIM_MST_RCC;
// Reset timer
TIM_MST_RESET_ON;
TIM_MST_RESET_OFF;
// Update the SystemCoreClock variable
SystemCoreClockUpdate();
// Configure time base
TimMasterHandle.Instance = TIM_MST;
TimMasterHandle.Init.Period = 0xFFFFFFFF;
TimMasterHandle.Init.Prescaler = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 us tick
TimMasterHandle.Init.ClockDivision = 0;
TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_Base_Init(&TimMasterHandle);
// Configure output compare channel 1 for mbed timeout (enabled later when used)
HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_1);
// Configure output compare channel 2 for HAL tick
HAL_TIM_OC_Start(&TimMasterHandle, TIM_CHANNEL_2);
PreviousVal = __HAL_TIM_GetCounter(&TimMasterHandle);
__HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_2, PreviousVal + HAL_TICK_DELAY);
// Configure interrupts
// Update interrupt used for 32-bit counter
// Output compare channel 1 interrupt for mbed timeout
// Output compare channel 2 interrupt for HAL tick
NVIC_SetVector(TIM_MST_IRQ, (uint32_t)timer_irq_handler);
NVIC_EnableIRQ(TIM_MST_IRQ);
// Enable interrupts
__HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_UPDATE); // For 32-bit counter
__HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC2); // For HAL tick
// Enable timer
HAL_TIM_Base_Start(&TimMasterHandle);
return HAL_OK;
}
/* --- Load and start micro-second delay counter --- */
void startMicroDelay(uint16_t Delay)
{
portENTER_CRITICAL();
if (Delay)
{
htim7.Instance->ARR = Delay;
HAL_TIM_Base_Start(&htim7);
while(htim7.Instance->CNT != 0)
{
}
HAL_TIM_Base_Stop(&htim7);
}
portEXIT_CRITICAL();
}
/**
* @brief Initializes all satellite power module instances.
* @param module_top: pointer to top solar panel side power module.
* @param module_bottom: pointer to bottom solar panel side power module.
* @param module_left: pointer to left solar panel side power module.
* @param module_right: pointer to right solar panel side power module
* @retval Error status for handling and debugging.
*/
EPS_soft_error_status EPS_PowerModule_init_ALL(EPS_PowerModule *module_top, EPS_PowerModule *module_bottom, EPS_PowerModule *module_left, EPS_PowerModule *module_right){
error_status = EPS_SOFT_ERROR_POWER_MODULE_INIT_ALL;
/*start timer3 pwm base generation (initialized pwm duty cycle from mx must be 0) */
HAL_TIM_Base_Start(&htim3);
/* initialize all power modules and dem mppt cotrol blocks.*/
error_status = EPS_SOFT_ERROR_POWER_MODULE_INIT_TOP;
EPS_PowerModule_init(module_top, MPPT_STARTUP_PWM_DUTYCYCLE, &htim3, PWM_TIM_CHANNEL_TOP, &hadc, ADC_CURRENT_CHANNEL_TOP, ADC_VOLTAGE_CHANNEL_TOP);
error_status = EPS_SOFT_ERROR_POWER_MODULE_INIT_BOTTOM;
EPS_PowerModule_init(module_bottom, MPPT_STARTUP_PWM_DUTYCYCLE, &htim3, PWM_TIM_CHANNEL_BOTTOM, &hadc, ADC_CURRENT_CHANNEL_BOTTOM, ADC_VOLTAGE_CHANNEL_BOTTOM);
error_status = EPS_SOFT_ERROR_POWER_MODULE_INIT_LEFT;
EPS_PowerModule_init(module_left, MPPT_STARTUP_PWM_DUTYCYCLE, &htim3, PWM_TIM_CHANNEL_LEFT, &hadc, ADC_CURRENT_CHANNEL_LEFT, ADC_VOLTAGE_CHANNEL_LEFT);
error_status = EPS_SOFT_ERROR_POWER_MODULE_INIT_RIGHT;
EPS_PowerModule_init(module_right, MPPT_STARTUP_PWM_DUTYCYCLE, &htim3, PWM_TIM_CHANNEL_RIGHT, &hadc, ADC_CURRENT_CHANNEL_RIGHT, ADC_VOLTAGE_CHANNEL_RIGHT);
return EPS_SOFT_ERROR_POWER_MODULE_INIT_ALL_COMPLETE;
}
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_USART1_UART_Init();
MX_SPI1_Init();
MX_TIM1_Init();
MX_TIM3_Init();
HAL_TIM_Base_Start(&htim1);
static char buf[50];
NRF24L01_Reset();
NRF24L01_Initialize();
HAL_Delay(150);
CX10_init();
HAL_Delay(50);
CX10_bind();
while (1) {
process_CX10();
HAL_Delay(6);
}
}
/**
* @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 144 Mhz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- TIM8 Peripheral Configuration ######################################*/
TIM_Config();
/*##-2- Configure the ADC3 peripheral ######################################*/
ADC_Config();
/*##-3- Start the conversion process and enable interrupt ##################*/
if(HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/*##-4- TIM8 counter enable ################################################*/
if(HAL_TIM_Base_Start(&htim) != HAL_OK)
{
/* Counter Enable Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
//--------------------------------------------------------------
// Init und start aller PWM Kanäle
//--------------------------------------------------------------
void
PWMDMA_Init (void)
{
uint16_t n;
// init vom Puffer
for (n = 0; n < PWM_DMA_WIDTH; n++)
{
PWM_DMA_PUFFER[n] = 0;
}
// 16 Kanäle
for (n = 0; n < 16; n++)
{
PWM_DMA_CH[n] = 0;
}
HAL_GPIO_WritePin (GPIOx, GPIO_PIN_All, GPIO_PIN_RESET);
__HAL_TIM_ENABLE_DMA(&htimx, TIM_DMA_UPDATE);
HAL_TIM_Base_Start (&htimx);
HAL_DMA_Start (&hdma, (uint32_t) PWM_DMA_PUFFER, (uint32_t) (&(GPIOx->ODR)), PWM_DMA_WIDTH);
}
