Зависает HAL_Delay

[InzhenerRadiotehnik]

Добрый день! Требуется помощь с освоением STM32F407VET6.
Общая задача - реализовать RS485 на данной отладочной плате. В ходе выполнения столкнулись с такой проблемой, как зависание в HAL_Delay(500).
Алгоритм действий для получения зависания:
0. Имеется две платы, код у каждой свой, писали 2 человека, оба кода приведены далее;
1. На первой плате поочерёдно нажимаются кнопки S1, S2, S3;
2. На второй плате поочерёдно нажимаются те же кнопки;
3. На первой плате нажимается кнопка S1, после чего плата зависает и без reset дальше не работает.

Искали решение данной проблемы, в том числе на данном форуме, но ничего не помогло.
Просим подсказать, как решить данную проблему.

Код 1 платы:

Спойлер

Код: Выделить всё

#include "stm32f4xx.h"                  

#include "stm32f4xx_hal.h"                        

#include "stm32f4xx_hal_rcc.h"    

#include "stm32f4xx_hal_gpio.h"   

#include "stm32f4xx_hal_uart.h"

#include "string.h"

#include "stdint.h"

#include "stdio.h"

#include "stdbool.h"

#include "stm32f4xx_hal_conf.h"        

#include "stm32f4xx.h"                  

#include "stm32f4xx_hal_usart.h"

 

 

#define RS485_DE_PIN GPIO_PIN_7

#define RS485_DE_GPIO_PORT GPIOD

#define RS45_DE_GPIO_CLK GPIOD_CLK_ENABLE

#define NUM_TICK_DELAY 500000

 

UART_HandleTypeDef huart;

      uint8_t bufferR = 0xFF;

 

      void SystemClock_Config(void)

{

  RCC_OscInitTypeDef RCC_OscInitStruct = {0};

  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

 

  __HAL_RCC_PWR_CLK_ENABLE();

  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

 

  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 = 4;

  HAL_RCC_OscConfig(&RCC_OscInitStruct);

  

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK |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;

HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

  }

       

 

      

            void MX_GPIO_Init()

           

      {

      __HAL_RCC_USART2_CLK_ENABLE();

      __HAL_RCC_GPIOE_CLK_ENABLE();

      __HAL_RCC_GPIOD_CLK_ENABLE();

      __HAL_RCC_GPIOH_CLK_ENABLE();

           

      GPIO_InitTypeDef GPIO_Port5;

      GPIO_Port5.Pin = GPIO_PIN_5 ;

      GPIO_Port5.Mode = GPIO_MODE_AF_PP;

      GPIO_Port5.Pull = GPIO_NOPULL;

            GPIO_Port5.Alternate = GPIO_AF7_USART2;

      GPIO_Port5.Speed = GPIO_SPEED_FREQ_HIGH;

      HAL_GPIO_Init(GPIOD, &GPIO_Port5);

           

      GPIO_InitTypeDef GPIO_Port6;

      GPIO_Port6.Pin = GPIO_PIN_6;

      GPIO_Port6.Mode = GPIO_MODE_AF_PP;

      GPIO_Port6.Pull = GPIO_NOPULL;

      GPIO_Port6.Alternate = GPIO_AF7_USART2;

        HAL_GPIO_Init(GPIOD, &GPIO_Port6);

           

      GPIO_InitTypeDef RSDE;

            RSDE.Pin = RS485_DE_PIN;

          RSDE.Mode= GPIO_MODE_OUTPUT_PP;

          RSDE.Speed = GPIO_SPEED_FREQ_LOW;

           RSDE.Pull = GPIO_NOPULL;

      HAL_GPIO_Init(RS485_DE_GPIO_PORT, &RSDE);

           

      GPIO_InitTypeDef Button1;

         Button1.Pin = GPIO_PIN_10;

      Button1.Mode= GPIO_MODE_INPUT;

        Button1.Pull = GPIO_NOPULL;

      HAL_GPIO_Init(GPIOE, &Button1);

 

      GPIO_InitTypeDef Button2;

         Button2.Pin = GPIO_PIN_11;

      Button2.Mode= GPIO_MODE_INPUT;

        Button2.Pull = GPIO_NOPULL;

      HAL_GPIO_Init(GPIOE, &Button2);

 

      GPIO_InitTypeDef Button3;

         Button3.Pin = GPIO_PIN_12;

      Button3.Mode= GPIO_MODE_INPUT;

        Button3.Pull = GPIO_NOPULL;

      HAL_GPIO_Init(GPIOE, &Button3);

           

      GPIO_InitTypeDef LED;

      

      LED.Pin = GPIO_PIN_13;

      LED.Mode = GPIO_MODE_OUTPUT_PP;

      LED.Pull = GPIO_NOPULL;

     LED.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

HAL_GPIO_Init(GPIOE, &LED);

      LED.Pin = GPIO_PIN_14;

      LED.Mode = GPIO_MODE_OUTPUT_PP;

      LED.Pull = GPIO_NOPULL;

     LED.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

HAL_GPIO_Init(GPIOE, &LED);

      LED.Pin = GPIO_PIN_15;

      LED.Mode = GPIO_MODE_OUTPUT_PP;

      LED.Pull = GPIO_NOPULL;

     LED.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

HAL_GPIO_Init(GPIOE, &LED);   

      

           

           }

void USART2_IRQHandler()

{

HAL_UART_IRQHandler(&huart);

      

      }

 

void RS485_Init()

{

__enable_irq();

huart.Instance = USART2;

huart.Init.BaudRate = 115200;

huart.Init.WordLength = UART_WORDLENGTH_9B;

huart.Init.StopBits = UART_STOPBITS_1;

huart.Init.Parity = UART_PARITY_EVEN;

huart.Init.Mode = UART_MODE_TX_RX;

huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;

huart.Init.OverSampling = UART_OVERSAMPLING_16;

HAL_UART_Init(&huart);

NVIC_EnableIRQ(USART2_IRQn);

HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);

      }

 

      void RS485TX(UART_HandleTypeDef *huart, uint8_t* message, uint8_t messageSize)

      {

      HAL_StatusTypeDef status;

      HAL_GPIO_WritePin(RS485_DE_GPIO_PORT, RS485_DE_PIN, GPIO_PIN_SET);

      HAL_UART_Transmit(huart, message, messageSize,HAL_MAX_DELAY);

      HAL_GPIO_WritePin(RS485_DE_GPIO_PORT, RS485_DE_PIN, GPIO_PIN_RESET);

      }

      
int main() 

 

{

   HAL_Init();

SystemClock_Config();

MX_GPIO_Init();

HAL_GPIO_WritePin(GPIOE, GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15, GPIO_PIN_SET);

RS485_Init();

            uint8_t message1 = 0x00U;

            uint8_t message2 = 0x01U;

            uint8_t message3 = 0x02U;

            uint8_t messageSENT1 = 0;

            uint8_t messageSENT2 = 0;

            uint8_t messageSENT3 = 0;

      

      

 

      while(1)

{                

 

           

           if ((HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_10) == GPIO_PIN_RESET) && !messageSENT1){

           RS485TX(&huart, (uint8_t*)&message1, sizeof(uint8_t)); 

             messageSENT1 = 1;

           HAL_Delay(500);

        for(uint32_t i = 0; i<NUM_TICK_DELAY; i++); 

           }

      if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_10) == GPIO_PIN_SET){

             messageSENT1 = 0;

           }

           

                      if ((HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_11) == GPIO_PIN_RESET) && !messageSENT2){

           RS485TX(&huart, (uint8_t*)&message2, sizeof(uint8_t));

             messageSENT2 = 1;}

           

      if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_11) == GPIO_PIN_SET){

             messageSENT2 = 0;}

           

                            if ((HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_12) == GPIO_PIN_RESET) && !messageSENT3){

           RS485TX(&huart, (uint8_t*)&message3, sizeof(uint8_t));

             messageSENT3 = 1;

                            }

      if(HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_12) == GPIO_PIN_SET){

             messageSENT3 = 0; 

      }

                 

HAL_UART_Receive_IT(&huart, &bufferR, 1);

      

           switch(bufferR) {

                 case 0x00U: 

                 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_13, GPIO_PIN_RESET);

                 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_14, GPIO_PIN_SET);

                 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_15, GPIO_PIN_SET);

                                       break;

                 case 0x01U:

                 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_14, GPIO_PIN_RESET);

                 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_13, GPIO_PIN_SET);

                 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_15, GPIO_PIN_SET);

                                       break;

                 case 0x02U:

                 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_15, GPIO_PIN_RESET);

                 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_13, GPIO_PIN_SET);

                 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_14, GPIO_PIN_SET);

                                       break;

                 default:

                       break;}

 

                 }

 

}

 

 

void SysTick_Handler(void)

{

HAL_IncTick();

HAL_SYSTICK_IRQHandler();

}

Код 2 платы:

Спойлер

Код: Выделить всё

#include "stm32f4xx_hal.h"              // Keil::Device:STM32Cube HAL:Common

#include "stm32f4xx_hal_rcc.h"    

#include "stm32f4xx_hal_gpio.h" 

#include "stm32f4xx_hal_uart.h"

#include "string.h"

#include "stdint.h"

#include "stdio.h"

#include "stdbool.h"

#include "stm32f4xx_hal_conf.h"         // Keil::Device:STM32Cube Framework:Classic

#include "stm32f4xx.h"                  // Device header

#include "stm32f4xx_hal_usart.h"

 

 

 

 

#define RS485_DE_PIN GPIO_PIN_7

#define RS485_DE_GPIO_PORT GPIOD

#define RS45_DE_GPIO_CLK GPIOD_CLK_ENABLE

#define NUM_TICK_DELAY 250000

 

      void rsTx (UART_HandleTypeDef *huart2, uint8_t* rsData, uint8_t messageSize);

      void SystemClock_Config(void);

 

      UART_HandleTypeDef huart2;

      bool receiveON = false;

      uint8_t rxData = 0xFFU;

      

      void rsTx (UART_HandleTypeDef *huart2, uint8_t* rsData, uint8_t messageSize)  //функция передачи

      {

      HAL_StatusTypeDef status;

      HAL_GPIO_WritePin(RS485_DE_GPIO_PORT, RS485_DE_PIN, GPIO_PIN_SET);

      HAL_UART_Transmit(huart2, rsData, messageSize,HAL_MAX_DELAY);

      //for(uint32_t i = 0; i<(NUM_TICK_DELAY / 5); i++); 

      HAL_GPIO_WritePin(RS485_DE_GPIO_PORT, RS485_DE_PIN, GPIO_PIN_RESET);

      }

 

           

           

void SystemClock_Config(void)

{

  RCC_OscInitTypeDef RCC_OscInitStruct = {0};

  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0}; 

  __HAL_RCC_PWR_CLK_ENABLE();                                                                                                                 //включение тактировнаия от внешнего кварца

  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

 

 

  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 = 4;

      

HAL_RCC_OscConfig(&RCC_OscInitStruct);

  

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK

                              |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;

HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

      

      

 

 

void USART2_IRQHandler()

      {

      HAL_UART_IRQHandler(&huart2);

      }

      

 

 

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart2) {

  if (huart2->Instance == USART2) {

    receiveON = true;

      HAL_UART_Receive_IT(huart2, &rxData, 1);

  }

}

 

int main(void)

{

   HAL_Init();

      

SystemClock_Config();

      

__HAL_RCC_GPIOE_CLK_ENABLE();                                                           //включение тактирования портов

__HAL_RCC_USART2_CLK_ENABLE();                                                              

__HAL_RCC_GPIOH_CLK_ENABLE();

__HAL_RCC_GPIOD_CLK_ENABLE();

 

GPIO_InitTypeDef     RSTx_Pin;                                                                      //описание Tx

  RSTx_Pin.Pin = GPIO_PIN_5;

RSTx_Pin.Mode = GPIO_MODE_AF_PP;

RSTx_Pin.Speed = GPIO_SPEED_FREQ_HIGH;

RSTx_Pin.Alternate = GPIO_AF7_USART2;

HAL_GPIO_Init(GPIOD,&RSTx_Pin);                                                                  //инициализация Tx                                                           

GPIO_InitTypeDef     RSRx_Pin;                  

  RSRx_Pin.Pin = GPIO_PIN_6;                                                                      //описание Rx

RSRx_Pin.Mode = GPIO_MODE_AF_PP;

RSRx_Pin.Pull = GPIO_NOPULL;

RSRx_Pin.Alternate = GPIO_AF7_USART2;

HAL_GPIO_Init(GPIOD,&RSRx_Pin);                                                                  //инициализация Rx

      

      

      

      

GPIO_InitTypeDef RSDe;                                   //описание DE

      RSDe.Pin = RS485_DE_PIN;

    RSDe.Mode= GPIO_MODE_OUTPUT_PP;

    RSDe.Speed = GPIO_SPEED_FREQ_LOW;

     RSDe.Pull = GPIO_NOPULL;

HAL_GPIO_Init(RS485_DE_GPIO_PORT, &RSDe);                                           //инициализация DE

      

      

__enable_irq();

      huart2.Instance = USART2;                                   //описание UART

huart2.Init.BaudRate = 115200;

huart2.Init.WordLength = UART_WORDLENGTH_9B;

huart2.Init.StopBits = UART_STOPBITS_1;

huart2.Init.Parity = UART_PARITY_EVEN;

huart2.Init.Mode = UART_MODE_TX_RX;

huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;

huart2.Init.OverSampling = UART_OVERSAMPLING_16;

HAL_UART_Init(&huart2);                                                                                                   //инициализация UART

NVIC_EnableIRQ(USART2_IRQn);

HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);

 

      

      

      

      

GPIO_InitTypeDef BlinkLED;                                                             //описание переменной BlinkLED (настройка порта)

  BlinkLED.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15; //номера пинов 

BlinkLED.Mode = GPIO_MODE_OUTPUT_PP;                                             //режим работы

BlinkLED.Pull = GPIO_NOPULL;                                                                   //Pull режим

BlinkLED.Speed = GPIO_SPEED_FREQ_VERY_HIGH;                           //частота сигнала на пине

      

GPIO_InitTypeDef Baton;

     Baton.Pin = GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12;

    Baton.Mode = GPIO_MODE_IT_RISING;

    Baton.Pull = GPIO_PULLUP;

   Baton.Speed = GPIO_SPEED_FREQ_LOW;

      

HAL_GPIO_Init(GPIOE, &BlinkLED);                                                        // настройка вывода и порта

HAL_GPIO_Init(GPIOE, &Baton); 

      

      

HAL_GPIO_WritePin(GPIOE,GPIO_PIN_13,GPIO_PIN_SET); //отключение диодов

        for(uint32_t i = 0; i<NUM_TICK_DELAY; i++); 

      HAL_GPIO_WritePin(GPIOE,GPIO_PIN_14,GPIO_PIN_SET);

        for(uint32_t i = 0; i<NUM_TICK_DELAY; i++); 

      HAL_GPIO_WritePin(GPIOE,GPIO_PIN_15,GPIO_PIN_SET);      

        for(uint32_t i = 0; i<NUM_TICK_DELAY; i++); 

      

      bool sendMessage = false;     

      uint8_t rsMessage[3] = {0x00U, 0x01U, 0x02U};

      uint16_t pins[3] = {GPIO_PIN_13, GPIO_PIN_14, GPIO_PIN_15};

      uint8_t nMessage = 0xff;

      bool transmitON  = false;

 

 

           

      while(1)

      {

                 

                 

      if((HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_10) == GPIO_PIN_RESET) && !sendMessage)

           {

              sendMessage = true;

                 nMessage = 0;

                 

           }

      if((HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_11) == GPIO_PIN_RESET) && !sendMessage)

           {

              sendMessage = true;

                 nMessage = 1;

           }

      if((HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_12) == GPIO_PIN_RESET) && !sendMessage)

           {

              sendMessage = true;

                 nMessage = 2;

           }

           

           if (sendMessage && !transmitON)

           {

                 

           HAL_GPIO_WritePin(GPIOE,GPIO_PIN_13,GPIO_PIN_SET);

           HAL_GPIO_WritePin(GPIOE,GPIO_PIN_14,GPIO_PIN_SET);

           HAL_GPIO_WritePin(GPIOE,GPIO_PIN_15,GPIO_PIN_SET);

             for(uint32_t i = 0; i<NUM_TICK_DELAY; i++); 

                 

           HAL_GPIO_WritePin(GPIOE,pins[nMessage],GPIO_PIN_RESET);

           rsTx(&huart2, (uint8_t*)&rsMessage[nMessage], sizeof(uint8_t));

             for(uint32_t i = 0; i<NUM_TICK_DELAY; i++); 

           HAL_GPIO_WritePin(GPIOE,pins[nMessage],GPIO_PIN_SET);

               transmitON = true;

 

           }

      if((HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_10) == GPIO_PIN_SET) && transmitON && nMessage == 0)

                 {

              sendMessage = false;

                     transmitON = 0;

           }

           if((HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_11) == GPIO_PIN_SET) && transmitON && nMessage == 1)

                 {

              sendMessage = false;

                     transmitON = 0;

           }

           if((HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_12) == GPIO_PIN_SET) && transmitON && nMessage == 2)

                 {

              sendMessage = false;

                     transmitON = 0;

           }

                      

           

            HAL_UART_Receive_IT(&huart2, &rxData, 1);

      

                 if (receiveON)

                 {

           HAL_GPIO_WritePin(GPIOE,GPIO_PIN_13,GPIO_PIN_SET);

           HAL_GPIO_WritePin(GPIOE,GPIO_PIN_14,GPIO_PIN_SET);

           HAL_GPIO_WritePin(GPIOE,GPIO_PIN_15,GPIO_PIN_SET);

                 if (rxData <= 0x02)

           HAL_GPIO_WritePin(GPIOE,pins[rxData],GPIO_PIN_RESET);

                receiveON = false;

                 }

                 

 

      }

}

      void SysTick_Handler(void)

{

HAL_IncTick();

HAL_SYSTICK_IRQHandler();

}

[smacorp]

Например, составить грамотное ТЗ (или какое поучится), разместить в разделе "Есть работа" и найти хорошего специалиста, который сможет и захочет помочь - вот наиболее быстрый и правильный вариант решения, если самим не получается. А так я сомневаюсь, что кто-то будет серьёзно анализировать чужие портянки кода и, тем более, моделировать это в железе.

[Аlex]

Просим подсказать, как решить данную проблему.

Очень просто - включить отладку и посмотреть, что происходит.

[InzhenerRadiotehnik]

Аlex, заходит в delay и висит там. В отладчике и поняли, что delay все портит.

[HardWareMan]

[uquote="InzhenerRadiotehnik",url="/forum/viewtopic.php?p=4622238#p4622238"]Аlex, заходит в delay и висит там. В отладчике и поняли, что delay все портит.[/uquote]
При этом тики системного таймера происходят? Систиковое прерывание вызывается?

[InzhenerRadiotehnik]

HardWareMan, нет, именно висит в delay. Тиков нет.

[GARMIN]

Ни систик не настроен, ни прерывания не разрешены. RTFM.

[InzhenerRadiotehnik]

GARMIN, а как это сделать?

[GARMIN]

Примерно так:

Спойлер

Код: Выделить всё

/// Update the time base
  SysTick_Config (160000000 / TICK_FREQ_HZ);
  __enable_irq ();

__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
{
  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
  {
    return (1UL);                                                   /* Reload value impossible */
  }

  SysTick->LOAD  = (uint32_t)(ticks - 1UL);                         /* set reload register */
  NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
  SysTick->VAL   = 0UL;                                             /* Load the SysTick Counter Value */
  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
                   SysTick_CTRL_TICKINT_Msk   |
                   SysTick_CTRL_ENABLE_Msk;                         /* Enable SysTick IRQ and SysTick Timer */
  return (0UL);                                                     /* Function successful */
}

Но это для STM32G491. Для вашего контроллера посмотрите даташит и скорректируйте по необходимости.

[InzhenerRadiotehnik]

GARMIN, большое спасибо!

[HardWareMan]

[uquote="GARMIN",url="/forum/viewtopic.php?p=4622360#p4622360"]Примерно так:[/uquote]
Там же есть методы у HAL_, зачем прямое регистрописание?

Код: Выделить всё

HAL_SYSTICK_Config( HAL_RCC_GetHCLKFreq()/1000 );
HAL_SYSTICK_CLKSourceConfig( SYSTICK_CLKSOURCE_HCLK );

Этого достаточно. А в другом проекте, где у меня таймер систика занят я просто вызываю HAL_IncTick(); в своём обработчике и всё.

[GARMIN]

[uquote="HardWareMan",url="/forum/viewtopic.php?p=4622490#p4622490"]Там же есть методы у HAL_, зачем прямое регистрописание?[/uquote]
Что вы там с халом пишете, мне неведомо. Я пишу так, как показал на примере.

[HardWareMan]

[uquote="GARMIN",url="/forum/viewtopic.php?p=4622649#p4622649"][uquote="HardWareMan",url="/forum/viewtopic.php?p=4622490#p4622490"]Там же есть методы у HAL_, зачем прямое регистрописание?[/uquote]
Что вы там с халом пишете, мне неведомо. Я пишу так, как показал на примере.[/uquote]
Во-первых, это ТС пишет HALом, а значит ему следует давать совет как правильно пользоваться этим самым HALом. Во-вторых вы привели просто исходник процедуры HAL_SYSTICK_Config(). А про важную настройку HAL_SYSTICK_CLKSourceConfig() технично умолчали.

[GARMIN]

HardWareMan, вы явно не читатель.
Потому что

Код: Выделить всё

SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
                   SysTick_CTRL_TICKINT_Msk   |
                   SysTick_CTRL_ENABLE_Msk;

как раз и устанавливает источник тактирования систика.
Тучше спросим у ТС, как у него дела.

[HardWareMan]

[uquote="GARMIN",url="/forum/viewtopic.php?p=4622949#p4622949"]HardWareMan, вы явно не читатель.
Потому что

Код: Выделить всё

SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
                   SysTick_CTRL_TICKINT_Msk   |
                   SysTick_CTRL_ENABLE_Msk;

как раз и устанавливает источник тактирования систика.
Тучше спросим у ТС, как у него дела.[/uquote]
А как вы думаете, что означает _Msk в названиях констант? Подсказка под спойлером.

Спойлер

[GARMIN]

HardWareMan, поздравляю, вы уже перешли с Хала на CMSIS!
Правда по невнимательности вы попутали названия битов, но всё равно, вы сами разобрались с тактированием систика без Хала.
RTFM работает!

[HardWareMan]

[uquote="GARMIN",url="/forum/viewtopic.php?p=4623296#p4623296"]HardWareMan, поздравляю, вы уже перешли с Хала на CMSIS!
Правда по невнимательности вы попутали названия битов, но всё равно, вы сами разобрались с тактированием систика без Хала.
RTFM работает![/uquote]
Не нужно меня поздравлять, я CMSIS использую с самого начала, точнее, в MikroE я просто использовал регистры и константы из Reference Manual. Я даже StdPeriph не использовал, когда он был доступен для Eclipse и ARM eabi, в до HALовскую бытность. И вообще, не важно что я использую. Важно что использует ТС. А он, я ещё раз напомню, использует HAL. Значит и помогать ему надо в рамках этого HAL.

[GARMIN]

HardWareMan, уважаемый, я с вами не согласен. Если вы можете использовать различные способы управления МК, тогда почему отказываете в этом ТС?
Например, человек из санатория тонет, просит помощи. Ему должен помогать только спасатель из этого санатория и со спасательным кругом с логотипом санатория?

[HardWareMan]

[uquote="GARMIN",url="/forum/viewtopic.php?p=4623618#p4623618"]HardWareMan, уважаемый, я с вами не согласен. Если вы можете использовать различные способы управления МК, тогда почему отказываете в этом ТС?
Например, человек из санатория тонет, просит помощи. Ему должен помогать только спасатель из этого санатория и со спасательным кругом с логотипом санатория?[/uquote]
Это всё прекрасно. Я и сам был как вы лет 15 назад. Но я со временем научился отвечать на заданные вопросы, а не учить людей жить правильно. Человек спросил за HAL. Мне не интересно, почему он на нём, он задал вполне конкретный вопрос вполне конкретном контексте. Так почему бы ему не ответить в этом же контексте, а не учить жизни со словами "Да ты ламер, RTFM и вообще используй CMSIS!"? Кстати, спасибо за напоминание, ощущение, что я такое слышал в прошлой жизни...

PS А аналогия у вас кривая. Абсолютно не соответствует действительности. Ну не согласны вы со мной - да и бог с ним. Я не имею желания спорить с вами, поэтому прекращаю отвечать вам не по делу в данном топике. Подожду ответа ТС, если он соизволит.