MyLibs 1.0
Расширенные библиотеки для STM32
Loading...
Searching...
No Matches
__general_tim.c
1/**
2 **************************************************************************
3 * @file general_tim.c
4 * @brief Модуль для инициализации таймеров.
5 **************************************************************************
6 @verbatim
7 //-------------------Функции-------------------//
8 Functions: user init
9 - TIM_Base_Init Инициализация TIM
10 - TIM_Encoder_Init Инициализация режима энкодера
11 - TIM_Output_PWM_Init Инициализация PWM с выводом на GPIO
12 - TIM_OC_Comparator_Init Инициализация TIM как компаратора
13
14 Functions: user
15 - TIM_Delay Задержка с помощью TIM
16
17 Functions: tim initialize
18 - TIM_Base_MspInit Аналог HAL_MspInit для таймера
19 - TIM_Base_MspDeInit Аналог HAL_MspDeInit для таймера
20 @endverbatim
21 *************************************************************************/
22#include "general_tim.h"
23#include "general_gpio.h"
24
25//-------------------------------------------------------------------
26//-------------------------TIM INIT FUNCTIONS------------------------
27/**
28 * @brief Initialize TIM with TIM_SettingsTypeDef structure.
29 * @param stim - указатель на структуру с настройками таймера.
30 * @return HAL status.
31 * @note Данная структура содержит хендл таймера и структуры для его настройки.
32 */
33HAL_StatusTypeDef TIM_Base_Init(TIM_SettingsTypeDef *stim)
34{ // function takes structure for init
35 // check that htim is defined
36 if (stim->htim.Instance == NULL)
37 return HAL_ERROR;
38
39
40
41 if(stim->sTickBaseUS) // if tickbase isnt disable
42 {
43 if(stim->sTimAHBFreqMHz == NULL)
44 return HAL_ERROR;
45 stim->htim.Init.Prescaler = (stim->sTimAHBFreqMHz*stim->sTickBaseUS) - 1;
46
47 if ((stim->sTimFreqHz != NULL))
48 stim->htim.Init.Period = ((1000000/stim->sTickBaseUS) / stim->sTimFreqHz) - 1;
49 else if (stim->htim.Init.Period == NULL)
50 stim->htim.Init.Period = 0xFFFF;
51
52 if(stim->sTickBasePrescaler)
53 {
54 stim->htim.Init.Prescaler = (stim->htim.Init.Prescaler + 1)/stim->sTickBasePrescaler - 1;
55 stim->htim.Init.Period = (stim->htim.Init.Period + 1)*stim->sTickBasePrescaler - 1;
56 }
57 else
58 stim->sTickBasePrescaler = 1;
59 }
60
61 // fix overflow of presc and period if need
62 for(int i = 0; (stim->htim.Init.Prescaler > 0xFFFF) || (stim->htim.Init.Period > 0xFFFF); i++)
63 {
64 if (i>10) // if it isnt fixed after 10 itteration - return HAL_ERRPOR
65 {
66 return HAL_ERROR;
67 }
68
69 // if timbase is too big (prescaller too big for choosen base from MHZ)
70 if(stim->htim.Init.Prescaler > 0xFFFF)
71 {
72 // переносим часть пресскалера в период
73 stim->htim.Init.Prescaler = ((stim->htim.Init.Prescaler + 1)/2) - 1;
74 stim->htim.Init.Period = ((stim->htim.Init.Period + 1)*2) - 1;
75 // обновляем TickBase, если есть куда обновлять
76 if(stim->sTickBaseUS > 1)
77 stim->sTickBaseUS /= 2;
78 // обновляем sTickBasePrescaler, если sTickBaseUS - уже в минимуме
79 else if (stim->sTickBaseUS == 1)
80 stim->sTickBasePrescaler *= 2;
81 else // if TickBase = 0 - return error
82 return HAL_ERROR;
83 }
84 // if freq is too low (period too big for choosen base)
85 if(stim->htim.Init.Period > 0xFFFF)
86 {
87 // переносим часть периода в прескалер
88 stim->htim.Init.Period = ((stim->htim.Init.Period + 1)/2) - 1;
89 stim->htim.Init.Prescaler = ((stim->htim.Init.Prescaler + 1)*2) - 1;
90 // обновляем TickBase
91 stim->sTickBaseUS *= 2;
92 }
93 }
94
95 //-------------TIM BASE INIT----------------
96 // tim base init
97 TIM_Base_MspInit(&stim->htim, stim->sTimMode);
98 if (HAL_TIM_Base_Init(&stim->htim) != HAL_OK)
99 {
100 MyLibs_Error_Handler();
101 return HAL_ERROR;
102 }
103
104 //-------------CLOCK SRC INIT---------------
105 // fill sClockSourceConfig if its NULL
106 if (stim->sClockSourceConfig.ClockSource == NULL)
107 stim->sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
108 // clock source init
109 if (HAL_TIM_ConfigClockSource(&stim->htim, &stim->sClockSourceConfig) != HAL_OK)
110 {
111 MyLibs_Error_Handler();
112 return HAL_ERROR;
113 }
114
115 //--------------SLAVE INIT------------------
116 // if slave mode enables - config it
117 if (stim->sSlaveConfig.SlaveMode)
118 {
119 // slave mode init
120 if (HAL_TIM_SlaveConfigSynchro(&stim->htim, &stim->sSlaveConfig) != HAL_OK)
121 {
122 MyLibs_Error_Handler();
123 return HAL_ERROR;
124 }
125 }
126 //--------------MASTER INIT-----------------
127 // master mode init
128 if (HAL_TIMEx_MasterConfigSynchronization(&stim->htim, &stim->sMasterConfig) != HAL_OK)
129 {
130 MyLibs_Error_Handler();
131 return HAL_ERROR;
132 }
133
134 //--------------BDTR INIT-----------------
135 if (HAL_TIMEx_ConfigBreakDeadTime(&stim->htim, &stim->sBreakDeadTimeConfig) != HAL_OK)
136 {
137 MyLibs_Error_Handler();
138 return HAL_ERROR;
139 }
140
141 //----------------IT CLEAR-------------------
142 __HAL_TIM_CLEAR_IT(&stim->htim, TIM_IT_UPDATE);
143
144
145 // обновляем TickBase
146 #ifdef UPDATE_TIM_PARAMS_AFTER_INITIALIZATION
147 stim->sTickBaseUS = (stim->htim.Instance->PSC+1)*stim->sTickBasePrescaler/(stim->sTimAHBFreqMHz);
148 if(stim->sTickBaseUS == 0) // if prescaler is too high
149 { // recalc what is prescaler irl
150 stim->sTickBaseUS = 1;
151 stim->sTickBasePrescaler = stim->sTimAHBFreqMHz/(stim->htim.Instance->PSC+1);
152 }
153 #endif
154 stim->htim.Instance->CNT = 0;
155 return HAL_OK;
156}
157
158
159
160/**
161 * @brief Initialize TIM Encoder functional.
162 * @param htim - указатель на хендл таймера.
163 * @param sConfigOC - указатель на настрйоки канала таймера.
164 * @param GPIOx - порт для приема енкодера.
165 * @param GPIO_PIN1 - первый пин для енкодера.
166 * @param GPIO_PIN2 - второй пин для енкодера.
167 * @param GPIO_PIN_SW - пин для кнопки енкодера.
168 * @return HAL status.
169 */
170HAL_StatusTypeDef TIM_Encoder_Init(TIM_EncoderTypeDef *henc, TIM_HandleTypeDef *htim)
171{
172 GPIO_InitTypeDef GPIO_InitStruct = {0};
173 HAL_StatusTypeDef RES = HAL_ERROR;
174 henc->htim = htim;
175
176 // setup channel for pwm
177 RES = HAL_TIM_Encoder_Init(henc->htim, &henc->sConfig);
178 if (RES != HAL_OK)
179 {
180 MyLibs_Error_Handler();
181 return RES;
182 }
183 // choose port for enable clock
184 RES = GPIO_Clock_Enable(henc->GPIOx);
185 if(RES != HAL_OK)
186 {
187 MyLibs_Error_Handler();
188 return RES;
189 }
190
191 GPIO_InitStruct.Pin = henc->GPIO_PIN_TI1|henc->GPIO_PIN_TI2;
192 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
193 GPIO_InitStruct.Pull = GPIO_PULLUP;
194 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
195 GPIO_InitStruct.Alternate = TIM_Alternate_Mapping(henc->htim->Instance);
196 if(GPIO_InitStruct.Alternate)
197 HAL_GPIO_Init(henc->GPIOx, &GPIO_InitStruct);
198
199 if(henc->GPIO_PIN_SW)
200 {
201 /*Configure switch pin */
202 GPIO_InitStruct.Pin = henc->GPIO_PIN_SW;
203 GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
204 GPIO_InitStruct.Pull = GPIO_PULLUP;
205 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
206 }
207
208 return HAL_OK;
209}
210
211/**
212 * @brief Initialize PWM Channel and GPIO for output.
213 * @param htim - указатель на хендл таймера.
214 * @param sConfigOC - указатель на настрйоки канала таймера.
215 * @param TIM_CHANNEL - канал таймера для настройки.
216 * @param GPIOx - порт для вывода ШИМ.
217 * @param GPIO_PIN - пин для вывода ШИМ.
218 * @return HAL status.
219 */
220HAL_StatusTypeDef TIM_Output_PWM_Init(TIM_HandleTypeDef *htim, TIM_OC_InitTypeDef *sConfigOC, uint32_t TIM_CHANNEL, GPIO_TypeDef *GPIOx, uint32_t GPIO_PIN)
221{
222 GPIO_InitTypeDef GPIO_InitStruct = {0};
223 HAL_StatusTypeDef RES = HAL_ERROR;
224
225 // setup channel for pwm
226 RES = HAL_TIM_PWM_ConfigChannel(htim, sConfigOC, TIM_CHANNEL);
227 if (RES != HAL_OK)
228 {
229 MyLibs_Error_Handler();
230 return RES;
231 }
232 // choose port for enable clock
233 RES = GPIO_Clock_Enable(GPIOx);
234 if(RES != HAL_OK)
235 {
236 MyLibs_Error_Handler();
237 return RES;
238 }
239
240 GPIO_InitStruct.Pin = GPIO_PIN;
241 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
242 if(sConfigOC->OCPolarity == TIM_OCNPOLARITY_HIGH)
243 GPIO_InitStruct.Pull = GPIO_PULLDOWN;
244 else
245 GPIO_InitStruct.Pull = GPIO_PULLUP;
246 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
247 GPIO_InitStruct.Alternate = TIM_Alternate_Mapping(htim->Instance);
248 if(GPIO_InitStruct.Alternate)
249 HAL_GPIO_Init(GPIOx, &GPIO_InitStruct);
250
251 return HAL_OK;
252}
253
254/**
255 * @brief Initialize OC Comparator.
256 * @param htim - указатель на хендл таймера.
257 * @param TIM_CHANNEL - канал таймера для настройки.
258 * @return HAL status.
259 */
260HAL_StatusTypeDef TIM_OC_Comparator_Init(TIM_HandleTypeDef *htim, uint32_t TIM_CHANNEL)
261{
262 TIM_OC_InitTypeDef sConfigOC = {0};
263 HAL_StatusTypeDef RES = HAL_ERROR;
264
265 sConfigOC.OCMode = TIM_OCMODE_ACTIVE;
266 sConfigOC.Pulse = 0;
267 sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
268
269 RES = HAL_TIM_OC_ConfigChannel(htim, &sConfigOC, TIM_CHANNEL);
270 if (RES != HAL_OK)
271 {
272 MyLibs_Error_Handler();
273 return RES;
274 }
275 return RES;
276}
277
278
279
280//-------------------------------------------------------------------
281//-------------------------TIM USER FUNCTIONS------------------------
282/**
283 * @brief Delay via TIM.
284 * @param htim - указатель на хендл таймера.
285 * @param delay - задержка в тиках таймера.
286 * @return HAL status.
287 * @note Таймер должен быть уже запущен.
288 */
289HAL_StatusTypeDef TIM_Delay(TIM_HandleTypeDef *htim, uint16_t delay)
290{
291 if(delay >= htim->Instance->ARR)
292 {
293 return HAL_ERROR;
294 }
295 htim->Instance->CNT = 0;
296 while(1)
297 {
298 if(htim->Instance->CNT > delay)
299 {
300 return HAL_OK;
301 }
302 }
303}
304
305/**
306 * @brief Start delay via TIM.
307 * @param htim - указатель на хендл таймера.
308 * @return HAL status.
309 * @note Таймер должен быть уже запущен.
310 */
311HAL_StatusTypeDef TIM_Delay_Start(TIM_HandleTypeDef *htim)
312{
313 htim->Instance->CNT = 0;
314
315 return HAL_OK;
316}
317
318/**
319 * @brief Wait Delay via TIM without blocking app.
320 * @param htim - указатель на хендл таймера.
321 * @param delay - задержка в тиках таймера.
322 * @return HAL status.
323 * @note Перед ожиданием задержки надо запутстить таймер её @ref TIM_Delay_Start
324 * @note Таймер не должен использоваться на время этой задержки
325 */
326HAL_StatusTypeDef TIM_Delay_NonBlocking(TIM_HandleTypeDef *htim, uint16_t delay)
327{
328 if(delay >= htim->Instance->ARR)
329 {
330 return HAL_ERROR;
331 }
332
333 if(htim->Instance->CNT <= delay)
334 {
335 return HAL_BUSY;
336 }
337 else
338 {
339 return HAL_OK;
340 }
341}
342
343/**
344 * @brief Initialize TIMs clock and interrupt.
345 * @param htim - указатель на хендл таймера.
346 * @note Чтобы не генерировать функцию с иницилизацией неиспользуемых таймеров,
347 дефайнами в general_tim.h определяются используемые таймеры.
348 */
349void TIM_Base_MspInit(TIM_HandleTypeDef* htim, TIM_ITModeTypeDef it_mode)
350{
351 it_mode = it_mode&TIM_IT_CONF;
352#ifdef USE_TIM1
353 if(htim->Instance==TIM1)
354 {
355 /* TIM2 clock enable */
356 __HAL_RCC_TIM1_CLK_ENABLE();
357
358 /* TIM2 interrupt Init */
359 if(it_mode)
360 {
361 HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 0, 0);
362 HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);
363 }
364 }
365#endif
366#ifdef USE_TIM2
367 if(htim->Instance==TIM2)
368 {
369 /* TIM2 clock enable */
370 __HAL_RCC_TIM2_CLK_ENABLE();
371
372 /* TIM2 interrupt Init */
373 if(it_mode)
374 {
375 HAL_NVIC_SetPriority(TIM2_IRQn, 0, 0);
376 HAL_NVIC_EnableIRQ(TIM2_IRQn);
377 }
378 }
379#endif
380#ifdef USE_TIM3
381 if(htim->Instance==TIM3)
382 {
383 /* TIM3 clock enable */
384 __HAL_RCC_TIM3_CLK_ENABLE();
385
386 /* TIM3 interrupt Init */
387 if(it_mode)
388 {
389 HAL_NVIC_SetPriority(TIM3_IRQn, 0, 0);
390 HAL_NVIC_EnableIRQ(TIM3_IRQn);
391 }
392 }
393#endif
394#ifdef USE_TIM4
395 if(htim->Instance==TIM4)
396 {
397 /* TIM4 clock enable */
398 __HAL_RCC_TIM4_CLK_ENABLE();
399
400 /* TIM4 interrupt Init */
401 if(it_mode)
402 {
403 HAL_NVIC_SetPriority(TIM4_IRQn, 0, 0);
404 HAL_NVIC_EnableIRQ(TIM4_IRQn);
405 }
406 }
407#endif
408#ifdef USE_TIM5
409 if(htim->Instance==TIM5)
410 {
411 /* TIM5 clock enable */
412 __HAL_RCC_TIM5_CLK_ENABLE();
413
414 /* TIM5 interrupt Init */
415 if(it_mode)
416 {
417 HAL_NVIC_SetPriority(TIM5_IRQn, 0, 0);
418 HAL_NVIC_EnableIRQ(TIM5_IRQn);
419 }
420 }
421#endif
422#ifdef USE_TIM6
423 if(htim->Instance==TIM6)
424 {
425 /* TIM6 clock enable */
426 __HAL_RCC_TIM6_CLK_ENABLE();
427
428 /* TIM6 interrupt Init */
429 if(it_mode)
430 {
431 HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 0, 0);
432 HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
433 }
434 }
435#endif
436#ifdef USE_TIM7
437 if(htim->Instance==TIM7)
438 {
439 /* TIM7 clock enable */
440 __HAL_RCC_TIM7_CLK_ENABLE();
441
442 /* TIM7 interrupt Init */
443 if(it_mode)
444 {
445 HAL_NVIC_SetPriority(TIM7_IRQn, 0, 0);
446 HAL_NVIC_EnableIRQ(TIM7_IRQn);
447 }
448 }
449#endif
450#ifdef USE_TIM8
451 if(htim->Instance==TIM8)
452 {
453 /* TIM8 clock enable */
454 __HAL_RCC_TIM8_CLK_ENABLE();
455
456 /* TIM8 interrupt Init */
457 if(it_mode)
458 {
459 HAL_NVIC_SetPriority(TIM8_UP_TIM13_IRQn, 0, 0);
460 HAL_NVIC_EnableIRQ(TIM8_UP_TIM13_IRQn);
461 }
462 }
463#endif
464#ifdef USE_TIM9
465 if(htim->Instance==TIM9)
466 {
467 /* TIM9 clock enable */
468 __HAL_RCC_TIM9_CLK_ENABLE();
469
470 /* TIM9 interrupt Init */
471 if(it_mode)
472 {
473 HAL_NVIC_SetPriority(TIM1_BRK_TIM9_IRQn, 0, 0);
474 HAL_NVIC_EnableIRQ(TIM1_BRK_TIM9_IRQn);
475 }
476 }
477#endif
478#ifdef USE_TIM10
479 if(htim->Instance==TIM10)
480 {
481 /* TIM10 clock enable */
482 __HAL_RCC_TIM10_CLK_ENABLE();
483
484 /* TIM10 interrupt Init */
485 if(it_mode)
486 {
487 HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 0, 0);
488 HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);
489 }
490 }
491#endif
492#ifdef USE_TIM11
493 if(htim->Instance==TIM11)
494 {
495 /* TIM11 clock enable */
496 __HAL_RCC_TIM11_CLK_ENABLE();
497
498 /* TIM11 interrupt Init */
499 if(it_mode)
500 {
501 HAL_NVIC_SetPriority(TIM1_TRG_COM_TIM11_IRQn, 0, 0);
502 HAL_NVIC_EnableIRQ(TIM1_TRG_COM_TIM11_IRQn);
503 }
504 }
505#endif
506#ifdef USE_TIM12
507 if(htim->Instance==TIM12)
508 {
509 /* TIM12 clock enable */
510 __HAL_RCC_TIM12_CLK_ENABLE();
511
512 /* TIM12 interrupt Init */
513 if(it_mode)
514 {
515 HAL_NVIC_SetPriority(TIM8_BRK_TIM12_IRQn, 0, 0);
516 HAL_NVIC_EnableIRQ(TIM8_BRK_TIM12_IRQn);
517 }
518 }
519#endif
520#ifdef USE_TIM13
521 if(htim->Instance==TIM13)
522 {
523 /* TIM13 clock enable */
524 __HAL_RCC_TIM13_CLK_ENABLE();
525
526 /* TIM13 interrupt Init */
527 if(it_mode)
528 {
529 HAL_NVIC_SetPriority(TIM8_UP_TIM13_IRQn, 0, 0);
530 HAL_NVIC_EnableIRQ(TIM8_UP_TIM13_IRQn);
531 }
532 }
533#endif
534#ifdef USE_TIM14
535 if(htim->Instance==TIM14)
536 {
537 /* TIM14 clock enable */
538 __HAL_RCC_TIM14_CLK_ENABLE();
539
540 /* TIM14 interrupt Init */
541 if(it_mode)
542 {
543 HAL_NVIC_SetPriority(TIM8_TRG_COM_TIM14_IRQn, 0, 0);
544 HAL_NVIC_EnableIRQ(TIM8_TRG_COM_TIM14_IRQn);
545 }
546 }
547#endif
548}
549/**
550 * @brief DeInitialize TIMs clock and interrupt.
551 * @param htim - указатель на хендл таймера.
552 * @note Чтобы не генерировать функцию с деиницилизацией неиспользуемых таймеров,
553 дефайнами в general_tim.h определяются используемые таймеры.
554 */
555void TIM_Base_MspDeInit(TIM_HandleTypeDef* htim)
556{
557#ifdef USE_TIM1
558 if(htim->Instance==TIM1)
559 {
560 __HAL_RCC_TIM1_FORCE_RESET();
561 __HAL_RCC_TIM1_RELEASE_RESET();
562 }
563#endif
564#ifdef USE_TIM2
565 if(htim->Instance==TIM2)
566 {
567 __HAL_RCC_TIM2_FORCE_RESET();
568 __HAL_RCC_TIM2_RELEASE_RESET();
569 }
570#endif
571#ifdef USE_TIM3
572 if(htim->Instance==TIM3)
573 {
574 __HAL_RCC_TIM3_FORCE_RESET();
575 __HAL_RCC_TIM3_RELEASE_RESET();
576 }
577#endif
578#ifdef USE_TIM4
579 if(htim->Instance==TIM4)
580 {
581 __HAL_RCC_TIM4_FORCE_RESET();
582 __HAL_RCC_TIM4_RELEASE_RESET();
583 }
584#endif
585#ifdef USE_TIM5
586 if(htim->Instance==TIM5)
587 {
588 __HAL_RCC_TIM5_FORCE_RESET();
589 __HAL_RCC_TIM5_RELEASE_RESET();
590 }
591#endif
592#ifdef USE_TIM6
593 if(htim->Instance==TIM6)
594 {
595 __HAL_RCC_TIM6_FORCE_RESET();
596 __HAL_RCC_TIM6_RELEASE_RESET();
597 }
598#endif
599#ifdef USE_TIM7
600 if(htim->Instance==TIM7)
601 {
602 __HAL_RCC_TIM7_FORCE_RESET();
603 __HAL_RCC_TIM7_RELEASE_RESET();
604 }
605#endif
606#ifdef USE_TIM8
607 if(htim->Instance==TIM8)
608 {
609 __HAL_RCC_TIM8_FORCE_RESET();
610 __HAL_RCC_TIM8_RELEASE_RESET();
611 }
612#endif
613#ifdef USE_TIM9
614 if(htim->Instance==TIM9)
615 {
616 __HAL_RCC_TIM9_FORCE_RESET();
617 __HAL_RCC_TIM9_RELEASE_RESET();
618 }
619#endif
620#ifdef USE_TIM10
621 if(htim->Instance==TIM10)
622 {
623 __HAL_RCC_TIM10_FORCE_RESET();
624 __HAL_RCC_TIM10_RELEASE_RESET();
625 }
626#endif
627#ifdef USE_TIM11
628 if(htim->Instance==TIM11)
629 {
630 __HAL_RCC_TIM11_FORCE_RESET();
631 __HAL_RCC_TIM11_RELEASE_RESET();
632 }
633#endif
634#ifdef USE_TIM12
635 if(htim->Instance==TIM12)
636 {
637 __HAL_RCC_TIM12_FORCE_RESET();
638 __HAL_RCC_TIM12_RELEASE_RESET();
639 }
640#endif
641#ifdef USE_TIM13
642 if(htim->Instance==TIM13)
643 {
644 __HAL_RCC_TIM13_FORCE_RESET();
645 __HAL_RCC_TIM13_RELEASE_RESET();
646 }
647#endif
648#ifdef USE_TIM14
649 if(htim->Instance==TIM14)
650 {
651 __HAL_RCC_TIM14_FORCE_RESET();
652 __HAL_RCC_TIM14_RELEASE_RESET();
653 }
654#endif
655}
656//-------------------------TIM INIT FUNCTIONS------------------------
657//-------------------------------------------------------------------
general_gpio.h
Заголовочный файл для модуля инициализации портов.
MyLibs_Error_Handler
#define MyLibs_Error_Handler(params)
Error_Handler который будет вызыватся в библиотеке
Definition mylibs_defs.h:31
TIM_Alternate_Mapping
#define TIM_Alternate_Mapping(INSTANCE)
Маппинг альтернативной функции SPI между GPIO.
Definition general_gpio.h:61
GPIO_Clock_Enable
HAL_StatusTypeDef GPIO_Clock_Enable(GPIO_TypeDef *GPIOx)
Включить тактирование порта GPIO.
Definition general_gpio.c:21
TIM_EncoderTypeDef
Definition __general_tim.h:94
TIM_SettingsTypeDef
Definition __general_tim.h:77