NIIETCM4 PD  v0.10.5
Драйвер периферии для микроконтроллеров на базе ядра ARM Cortex-M4
 Указатель Структуры данных Файлы Функции Переменные Перечисления Элементы перечислений Группы Страницы
niietcm4_pwm.c
См. документацию.
1 
29 /* Includes ------------------------------------------------------------------*/
30 #include "niietcm4_pwm.h"
31 
96 void PWM_PrescCmd(uint32_t Presc, FunctionalState State)
97 {
98  assert_param(IS_PWM_PRESC(Presc));
99  assert_param(IS_FUNCTIONAL_STATE(State));
100 
101  if (State == DISABLE)
102  {
103  NT_COMMON_REG->PWM_SYNC &= ~Presc;
104  }
105  else if (State == ENABLE)
106  {
107  NT_COMMON_REG->PWM_SYNC |= Presc;
108  }
109 }
110 
119 {
120  assert_param(IS_PWM_SYNC(SyncSelect));
121 
122  NT_COMMON_REG->PWM_CTRL_bit.SYNCSELECT = (uint32_t)SyncSelect;
123 }
124 
131 void PWM_DeInit(NT_PWM_TypeDef* PWMx)
132 {
133  RCC_PeriphRst_TypeDef PWMRst;
134 
135  assert_param(IS_PWM_ALL_PERIPH(PWMx));
136 
137  if (PWMx == NT_PWM0)
138  {
139  PWMRst = RCC_PeriphRst_PWM0;
140  }
141  else if (PWMx == NT_PWM1)
142  {
143  PWMRst = RCC_PeriphRst_PWM1;
144  }
145  else if (PWMx == NT_PWM2)
146  {
147  PWMRst = RCC_PeriphRst_PWM2;
148  }
149  else if (PWMx == NT_PWM3)
150  {
151  PWMRst = RCC_PeriphRst_PWM3;
152  }
153  else if (PWMx == NT_PWM4)
154  {
155  PWMRst = RCC_PeriphRst_PWM4;
156  }
157  else if (PWMx == NT_PWM5)
158  {
159  PWMRst = RCC_PeriphRst_PWM5;
160  }
161  else if (PWMx == NT_PWM6)
162  {
163  PWMRst = RCC_PeriphRst_PWM6;
164  }
165  else if (PWMx == NT_PWM7)
166  {
167  PWMRst = RCC_PeriphRst_PWM7;
168  }
169  else /* (PWMx == NT_PWM8) */
170  {
171  PWMRst = RCC_PeriphRst_PWM8;
172  }
173 
174  RCC_PeriphRstCmd(PWMRst, DISABLE);
175  RCC_PeriphRstCmd(PWMRst, ENABLE);
176 }
177 
190 void PWM_ChForceContCmd(NT_PWM_TypeDef* PWMx, PWM_Channel_TypeDef Channel, PWM_ChAction_TypeDef ChActionA, PWM_ChAction_TypeDef ChActionB)
191 {
192  assert_param(IS_PWM_ALL_PERIPH(PWMx));
193  assert_param(IS_PWM_CHANNEL(Channel));
194  assert_param(IS_PWM_CH_ACTION(ChActionA));
195  assert_param(IS_PWM_CH_ACTION(ChActionB));
196 
197  if (Channel == PWM_Channel_A)
198  {
199  PWMx->AQCSFRC_bit.CSFA = (uint32_t)ChActionA;
200  }
201  else if (Channel == PWM_Channel_B)
202  {
203  PWMx->AQCSFRC_bit.CSFB = (uint32_t)ChActionB;
204  }
205  else /* if (Channel == PWM_Channel_AB) */
206  {
207  PWMx->AQCSFRC = ((uint32_t)ChActionA<<PWM_AQCSFRC_CSFA_Pos) |
208  ((uint32_t)ChActionB<<PWM_AQCSFRC_CSFB_Pos);
209  }
210 }
211 
224 void PWM_ChForceConfig(NT_PWM_TypeDef* PWMx, PWM_Channel_TypeDef Channel, PWM_ChAction_TypeDef ChActionA, PWM_ChAction_TypeDef ChActionB)
225 {
226  assert_param(IS_PWM_ALL_PERIPH(PWMx));
227  assert_param(IS_PWM_CHANNEL(Channel));
228  assert_param(IS_PWM_CH_ACTION(ChActionA));
229  assert_param(IS_PWM_CH_ACTION(ChActionB));
230 
231  if (Channel == PWM_Channel_A)
232  {
233  PWMx->AQSFRC_bit.ACTSFA = (uint32_t)ChActionA;
234  }
235  else if (Channel == PWM_Channel_B)
236  {
237  PWMx->AQSFRC_bit.ACTSFB = (uint32_t)ChActionB;
238  }
239  else /* if (Channel == PWM_Channel_AB) */
240  {
241  PWMx->AQSFRC = ((uint32_t)ChActionA<<PWM_AQSFRC_ACTSFA_Pos) |
242  ((uint32_t)ChActionB<<PWM_AQSFRC_ACTSFB_Pos);
243  }
244 }
245 
254 void PWM_ChForceCmd(NT_PWM_TypeDef* PWMx, PWM_Channel_TypeDef Channel)
255 {
256  assert_param(IS_PWM_ALL_PERIPH(PWMx));
257  assert_param(IS_PWM_CHANNEL(Channel));
258 
259  if (Channel == PWM_Channel_A)
260  {
261  PWMx->AQSFRC_bit.OTSFA = 1;
262  }
263  else if (Channel == PWM_Channel_B)
264  {
265  PWMx->AQSFRC_bit.OTSFB = 1;
266  }
267  else /* if (Channel == PWM_Channel_AB) */
268  {
269  PWMx->AQSFRC |= (1<<PWM_AQSFRC_OTSFA_Pos) |
270  (1<<PWM_AQSFRC_OTSFB_Pos);
271  }
272 }
273 
282 void PWM_CTR_Init(NT_PWM_TypeDef* PWMx, PWM_CTR_Init_TypeDef* PWM_CTR_InitStruct)
283 {
284  assert_param(IS_PWM_ALL_PERIPH(PWMx));
285  assert_param(IS_PWM_CH_ACTION(PWM_CTR_InitStruct->PWM_ChAction_CTREqPeriod_A));
286  assert_param(IS_PWM_CH_ACTION(PWM_CTR_InitStruct->PWM_ChAction_CTREqPeriod_B));
287  assert_param(IS_PWM_CH_ACTION(PWM_CTR_InitStruct->PWM_ChAction_CTREqZero_A));
288  assert_param(IS_PWM_CH_ACTION(PWM_CTR_InitStruct->PWM_ChAction_CTREqZero_B));
289  assert_param(IS_PWM_CLK_DIV(PWM_CTR_InitStruct->PWM_ClkDiv));
290  assert_param(IS_PWM_CLK_DIV_EXTRA(PWM_CTR_InitStruct->PWM_ClkDivExtra));
291  assert_param(IS_PWM_CTR_MODE(PWM_CTR_InitStruct->PWM_CTR_Mode));
292  assert_param(IS_PWM_CTR_HALT(PWM_CTR_InitStruct->PWM_CTR_Halt));
293  assert_param(IS_PWM_LOAD_MODE(PWM_CTR_InitStruct->PWM_LoadMode_Period));
294  assert_param(IS_FUNCTIONAL_STATE(PWM_CTR_InitStruct->PWM_PhaseEn));
295  assert_param(IS_PWM_CTR_DIR(PWM_CTR_InitStruct->PWM_CTR_Dir_Phase));
296  assert_param(IS_PWM_CTR_SYNC_OUT(PWM_CTR_InitStruct->PWM_CTR_SyncOut));
297 
298  PWM_CTR_SetPhase(PWMx, PWM_CTR_InitStruct->PWM_Phase);
299 
300  PWMx->AQCTLA_bit.ZRO = (uint32_t)PWM_CTR_InitStruct->PWM_ChAction_CTREqZero_A;
301  PWMx->AQCTLA_bit.PRD = (uint32_t)PWM_CTR_InitStruct->PWM_ChAction_CTREqPeriod_A;
302  PWMx->AQCTLB_bit.ZRO = (uint32_t)PWM_CTR_InitStruct->PWM_ChAction_CTREqZero_B;
303  PWMx->AQCTLB_bit.PRD = (uint32_t)PWM_CTR_InitStruct->PWM_ChAction_CTREqPeriod_B;
304 
305  PWMx->TBCTL_bit.PHSDIR = (uint32_t)PWM_CTR_InitStruct->PWM_CTR_Dir_Phase;
306  PWMx->TBCTL_bit.CLKDIV = (uint32_t)PWM_CTR_InitStruct->PWM_ClkDiv;
307  PWMx->TBCTL_bit.HSPCLKDIV = (uint32_t)PWM_CTR_InitStruct->PWM_ClkDivExtra;
308  PWMx->TBCTL_bit.SYNCOSEL = (uint32_t)PWM_CTR_InitStruct->PWM_CTR_SyncOut;
309  PWMx->TBCTL_bit.PRDLD = (uint32_t)PWM_CTR_InitStruct->PWM_LoadMode_Period;
310  PWMx->TBCTL_bit.PHSEN = (uint32_t)PWM_CTR_InitStruct->PWM_PhaseEn;
311  PWMx->TBCTL_bit.CTRMODE = (uint32_t)PWM_CTR_InitStruct->PWM_CTR_Mode;
312 
313  PWM_CTR_SetPeriod(PWMx, PWM_CTR_InitStruct->PWM_Period);
314 }
315 
323 void PWM_CTR_StructInit(PWM_CTR_Init_TypeDef* PWM_CTR_InitStruct)
324 {
325  PWM_CTR_InitStruct->PWM_ChAction_CTREqPeriod_A = PWM_ChAction_None;
326  PWM_CTR_InitStruct->PWM_ChAction_CTREqPeriod_B = PWM_ChAction_None;
327  PWM_CTR_InitStruct->PWM_ChAction_CTREqZero_A = PWM_ChAction_None;
328  PWM_CTR_InitStruct->PWM_ChAction_CTREqZero_B = PWM_ChAction_None;
329  PWM_CTR_InitStruct->PWM_ClkDiv = PWM_ClkDiv_1;
330  PWM_CTR_InitStruct->PWM_ClkDivExtra = PWM_ClkDivExtra_1;
331  PWM_CTR_InitStruct->PWM_CTR_Mode = PWM_CTR_Mode_Up;
332  PWM_CTR_InitStruct->PWM_CTR_Halt = PWM_CTR_Halt_StopOnTBCLK;
333  PWM_CTR_InitStruct->PWM_LoadMode_Period = PWM_LoadMode_Shadow;
334  PWM_CTR_InitStruct->PWM_Period = 0;
335  PWM_CTR_InitStruct->PWM_Phase = 0;
336  PWM_CTR_InitStruct->PWM_PhaseEn = DISABLE;
337  PWM_CTR_InitStruct->PWM_CTR_Dir_Phase = PWM_CTR_Dir_Down;
338  PWM_CTR_InitStruct->PWM_CTR_SyncOut = PWM_CTR_SyncOut_SyncIn;
339 }
340 
350 FlagStatus PWM_CTR_Status(NT_PWM_TypeDef* PWMx, uint32_t CTR_Status)
351 {
352  FlagStatus Status;
353 
354  assert_param(IS_PWM_ALL_PERIPH(PWMx));
355  assert_param(IS_PWM_CTR_STATUS(CTR_Status));
356 
357  if (PWMx->TBSTS & CTR_Status)
358  {
359  Status = Flag_SET;
360  }
361  else
362  {
363  Status = Flag_CLEAR;
364  }
365 
366  return Status;
367 }
368 
377 void PWM_CTR_StatusClear(NT_PWM_TypeDef* PWMx, uint32_t CTR_Status)
378 {
379  assert_param(IS_PWM_ALL_PERIPH(PWMx));
380  assert_param(IS_PWM_CTR_STATUS(CTR_Status));
381 
382  PWMx->TBSTS = CTR_Status;
383 }
384 
392 void PWM_CTR_SetValue(NT_PWM_TypeDef* PWMx, uint32_t CTR_Val)
393 {
394  assert_param(IS_PWM_ALL_PERIPH(PWMx));
395  assert_param(IS_PWM_COUNTER_VAL(CTR_Val));
396 
397  PWMx->TBCTR = CTR_Val;
398 }
399 
407 void PWM_CTR_SetPeriod(NT_PWM_TypeDef* PWMx, uint32_t CTR_PeriodVal)
408 {
409  assert_param(IS_PWM_ALL_PERIPH(PWMx));
410  assert_param(IS_PWM_PERIOD_VAL(CTR_PeriodVal));
411 
412  PWMx->TBPRD = CTR_PeriodVal;
413 }
414 
422 void PWM_CTR_SetPhase(NT_PWM_TypeDef* PWMx, uint32_t CTR_PhaseVal)
423 {
424  assert_param(IS_PWM_ALL_PERIPH(PWMx));
425  assert_param(IS_PWM_PHASE_VAL(CTR_PhaseVal));
426 
427  PWMx->TBPHS_bit.TBPHS = CTR_PhaseVal;
428 }
429 
436 uint32_t PWM_CTR_GetValue(NT_PWM_TypeDef* PWMx)
437 {
438  assert_param(IS_PWM_ALL_PERIPH(PWMx));
439 
440  return PWMx->TBCTR;
441 }
442 
449 uint32_t PWM_CTR_GetPeriod(NT_PWM_TypeDef* PWMx)
450 {
451  assert_param(IS_PWM_ALL_PERIPH(PWMx));
452 
453  return PWMx->TBPRD;
454 }
455 
462 uint32_t PWM_CTR_GetPhase(NT_PWM_TypeDef* PWMx)
463 {
464  assert_param(IS_PWM_ALL_PERIPH(PWMx));
465 
466  return PWMx->TBPHS_bit.TBPHS;
467 }
468 
474 void PWM_CTR_SWSyncInCmd(NT_PWM_TypeDef* PWMx)
475 {
476  assert_param(IS_PWM_ALL_PERIPH(PWMx));
477 
478  PWMx->TBCTL_bit.SWFSYNC = 1;
479 }
480 
489 void PWM_CMP_Init(NT_PWM_TypeDef* PWMx, PWM_CMP_Init_TypeDef* PWM_CMP_InitStruct)
490 {
491  assert_param(IS_PWM_ALL_PERIPH(PWMx));
492  assert_param(IS_PWM_CH_ACTION(PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Down_A));
493  assert_param(IS_PWM_CH_ACTION(PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Up_A));
494  assert_param(IS_PWM_CH_ACTION(PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Down_A));
495  assert_param(IS_PWM_CH_ACTION(PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Up_A));
496  assert_param(IS_PWM_LOAD_EVENT(PWM_CMP_InitStruct->PWM_LoadEvent_CMPA));
497  assert_param(IS_PWM_LOAD_MODE(PWM_CMP_InitStruct->PWM_LoadMode_CMPA));
498  assert_param(IS_PWM_CH_ACTION(PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Down_B));
499  assert_param(IS_PWM_CH_ACTION(PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Up_B));
500  assert_param(IS_PWM_CH_ACTION(PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Down_B));
501  assert_param(IS_PWM_CH_ACTION(PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Up_B));
502  assert_param(IS_PWM_LOAD_EVENT(PWM_CMP_InitStruct->PWM_LoadEvent_CMPB));
503  assert_param(IS_PWM_LOAD_MODE(PWM_CMP_InitStruct->PWM_LoadMode_CMPB));
504 
505  PWMx->CMPCTL_bit.LOADAMODE = (uint32_t)PWM_CMP_InitStruct->PWM_LoadEvent_CMPA;
506  PWMx->CMPCTL_bit.LOADBMODE = (uint32_t)PWM_CMP_InitStruct->PWM_LoadEvent_CMPB;
507  PWMx->CMPCTL_bit.SHDWAMODE = (uint32_t)PWM_CMP_InitStruct->PWM_LoadMode_CMPA;
508  PWMx->CMPCTL_bit.SHDWBMODE = (uint32_t)PWM_CMP_InitStruct->PWM_LoadMode_CMPB;
509 
510  PWMx->AQCTLA_bit.CAD = (uint32_t)PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Down_A;
511  PWMx->AQCTLA_bit.CAU = (uint32_t)PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Up_A;
512  PWMx->AQCTLA_bit.CBD = (uint32_t)PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Down_A;
513  PWMx->AQCTLA_bit.CBU = (uint32_t)PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Up_A;
514  PWMx->AQCTLB_bit.CAD = (uint32_t)PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Down_B;
515  PWMx->AQCTLB_bit.CAU = (uint32_t)PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Up_B;
516  PWMx->AQCTLB_bit.CBD = (uint32_t)PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Down_B;
517  PWMx->AQCTLB_bit.CBU = (uint32_t)PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Up_B;
518 
519  PWM_CMP_SetA(PWMx, PWM_CMP_InitStruct->PWM_CMPA);
520  PWM_CMP_SetB(PWMx, PWM_CMP_InitStruct->PWM_CMPB);
521 }
522 
530 void PWM_CMP_StructInit(PWM_CMP_Init_TypeDef* PWM_CMP_InitStruct)
531 {
532  PWM_CMP_InitStruct->PWM_CMPA = 0;
533  PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Down_A = PWM_ChAction_None;
534  PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Up_A = PWM_ChAction_None;
535  PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Down_A = PWM_ChAction_None;
536  PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Up_A = PWM_ChAction_None;
537  PWM_CMP_InitStruct->PWM_LoadEvent_CMPA = PWM_LoadEvent_CTREqZero;
538  PWM_CMP_InitStruct->PWM_LoadMode_CMPA = PWM_LoadMode_Shadow;
539  PWM_CMP_InitStruct->PWM_CMPB = 0;
540  PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Down_B = PWM_ChAction_None;
541  PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPA_Up_B = PWM_ChAction_None;
542  PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Down_B = PWM_ChAction_None;
543  PWM_CMP_InitStruct->PWM_ChAction_CTREqCMPB_Up_B = PWM_ChAction_None;
544  PWM_CMP_InitStruct->PWM_LoadEvent_CMPB = PWM_LoadEvent_CTREqZero;
545  PWM_CMP_InitStruct->PWM_LoadMode_CMPB = PWM_LoadMode_Shadow;
546 }
547 
548 
556 void PWM_CMP_SetA(NT_PWM_TypeDef* PWMx, uint32_t CMPAVal)
557 {
558  assert_param(IS_PWM_ALL_PERIPH(PWMx));
559  assert_param(IS_PWM_CMP_VAL(CMPAVal));
560 
561  PWMx->CMPA_bit.CMPA = CMPAVal;
562 }
563 
571 void PWM_CMP_SetB(NT_PWM_TypeDef* PWMx, uint32_t CMPBVal)
572 {
573  assert_param(IS_PWM_ALL_PERIPH(PWMx));
574  assert_param(IS_PWM_CMP_VAL(CMPBVal));
575 
576  PWMx->CMPB_bit.CMPB = CMPBVal;
577 }
578 
585 uint32_t PWM_CMP_GetA(NT_PWM_TypeDef* PWMx)
586 {
587  assert_param(IS_PWM_ALL_PERIPH(PWMx));
588 
589  return PWMx->CMPA_bit.CMPA;
590 }
591 
598 uint32_t PWM_CMP_GetB(NT_PWM_TypeDef* PWMx)
599 {
600  assert_param(IS_PWM_ALL_PERIPH(PWMx));
601 
602  return PWMx->CMPB_bit.CMPB;
603 }
604 
616 FlagStatus PWM_CMP_Status(NT_PWM_TypeDef* PWMx, uint32_t CMP_Status)
617 {
618  FlagStatus Status;
619 
620  assert_param(IS_PWM_ALL_PERIPH(PWMx));
621  assert_param(IS_PWM_CMP_STATUS(CMP_Status));
622 
623  if (PWMx->CMPCTL & CMP_Status)
624  {
625  Status = Flag_SET;
626  }
627  else
628  {
629  Status = Flag_CLEAR;
630  }
631 
632  return Status;
633 }
634 
650 void PWM_HR_Init(NT_PWM_TypeDef* PWMx, PWM_HR_Init_TypeDef* PWM_HR_InitStruct)
651 {
652  assert_param(IS_PWM_HR_ALL_PERIPH(PWMx));
653  assert_param(IS_PWM_HR_CMP_LOAD(PWM_HR_InitStruct->PWM_HR_CMPLoad));
654  assert_param(IS_PWM_HR_MODE(PWM_HR_InitStruct->PWM_HR_Mode));
655  assert_param(IS_PWM_HR_EDGE(PWM_HR_InitStruct->PWM_HR_Edge));
656 
657  PWMx->HRCNFG_bit.HR_LOAD = (uint32_t)PWM_HR_InitStruct->PWM_HR_CMPLoad;
658  PWMx->HRCNFG_bit.CTLMODE = (uint32_t)PWM_HR_InitStruct->PWM_HR_Mode;
659  PWMx->HRCNFG_bit.EDGMODE = (uint32_t)PWM_HR_InitStruct->PWM_HR_Edge;
660 
661  PWM_HR_SetCMP(PWMx, PWM_HR_InitStruct->PWM_HR_CMP);
662  PWM_HR_SetPhase(PWMx, PWM_HR_InitStruct->PWM_HR_Phase);
663 }
664 
673 void PWM_HR_StructInit(PWM_HR_Init_TypeDef* PWM_HR_InitStruct)
674 {
675  PWM_HR_InitStruct->PWM_HR_CMPLoad = PWM_HR_CMPLoad_CTREqZero;
676  PWM_HR_InitStruct->PWM_HR_Mode = PWM_HR_Mode_CMP;
677  PWM_HR_InitStruct->PWM_HR_Edge = PWM_HR_Edge_None;
678  PWM_HR_InitStruct->PWM_HR_CMP = 0;
679  PWM_HR_InitStruct->PWM_HR_Phase = 0;
680 }
681 
689 void PWM_HR_SetCMP(NT_PWM_TypeDef* PWMx, uint32_t HR_CMPVal)
690 {
691  assert_param(IS_PWM_HR_ALL_PERIPH(PWMx));
692  assert_param(IS_PWM_HR_CMP_VAL(HR_CMPVal));
693 
694  PWMx->CMPA_bit.CMPAHR = HR_CMPVal;
695 }
696 
704 void PWM_HR_SetPhase(NT_PWM_TypeDef* PWMx, uint32_t HR_PhaseVal)
705 {
706  assert_param(IS_PWM_HR_ALL_PERIPH(PWMx));
707  assert_param(IS_PWM_HR_PHASE_VAL(HR_PhaseVal));
708 
709  PWMx->TBPHS_bit.TBPHSHR = HR_PhaseVal;
710 }
711 
718 uint32_t PWM_HR_GetCMP(NT_PWM_TypeDef* PWMx)
719 {
720  assert_param(IS_PWM_HR_ALL_PERIPH(PWMx));
721 
722  return PWMx->CMPA_bit.CMPAHR;
723 }
724 
731 uint32_t PWM_HR_GetPhase(NT_PWM_TypeDef* PWMx)
732 {
733  assert_param(IS_PWM_HR_ALL_PERIPH(PWMx));
734 
735  return PWMx->TBPHS_bit.TBPHSHR;
736 }
737 
749 void PWM_ITConfig(NT_PWM_TypeDef* PWMx, PWM_Event_TypeDef Event, uint32_t ITPeriod)
750 {
751  assert_param(IS_PWM_ALL_PERIPH(PWMx));
752  assert_param(IS_PWM_EVENT(Event));
753  assert_param(IS_PWM_IT_PERIOD(ITPeriod));
754 
755  PWMx->ETSEL_bit.INTSEL = (uint32_t)Event;
756  PWMx->ETPS_bit.INTPRD = ITPeriod;
757 }
758 
767 void PWM_ITCmd(NT_PWM_TypeDef* PWMx, FunctionalState State)
768 {
769  assert_param(IS_PWM_ALL_PERIPH(PWMx));
770  assert_param(IS_FUNCTIONAL_STATE(State));
771 
772  PWMx->ETSEL_bit.INTEN = (uint32_t)State;
773 }
774 
781 uint32_t PWM_GetITEventCount(NT_PWM_TypeDef* PWMx)
782 {
783  assert_param(IS_PWM_ALL_PERIPH(PWMx));
784 
785  return PWMx->ETPS_bit.INTCNT;
786 }
787 
794 FlagStatus PWM_ITStatus(NT_PWM_TypeDef* PWMx)
795 {
796  FlagStatus Status;
797 
798  assert_param(IS_PWM_ALL_PERIPH(PWMx));
799 
800  if (PWMx->ETFLG_bit.INT)
801  {
802  Status = Flag_SET;
803  }
804  else
805  {
806  Status = Flag_CLEAR;
807  }
808 
809  return Status;
810 }
811 
818 void PWM_ITStatusClear(NT_PWM_TypeDef* PWMx)
819 {
820  assert_param(IS_PWM_ALL_PERIPH(PWMx));
821 
822  PWMx->ETCLR_bit.INT = 1;
823 }
824 
831 FlagStatus PWM_ITPendStatus(NT_PWM_TypeDef* PWMx)
832 {
833  FlagStatus Status;
834 
835  assert_param(IS_PWM_ALL_PERIPH(PWMx));
836 
837  if (PWMx->INTCLR_bit.INT)
838  {
839  Status = Flag_SET;
840  }
841  else
842  {
843  Status = Flag_CLEAR;
844  }
845 
846  return Status;
847 }
848 
855 void PWM_ITPendClear(NT_PWM_TypeDef* PWMx)
856 {
857  assert_param(IS_PWM_ALL_PERIPH(PWMx));
858 
859  PWMx->INTCLR_bit.INT = 1;
860 }
861 
868 void PWM_ITForce(NT_PWM_TypeDef* PWMx)
869 {
870  assert_param(IS_PWM_ALL_PERIPH(PWMx));
871 
872  PWMx->ETFRC_bit.INT = 1;
873 }
874 
883 void PWM_DB_Init(NT_PWM_TypeDef* PWMx, PWM_DB_Init_TypeDef* PWM_DB_InitStruct)
884 {
885  assert_param(IS_PWM_ALL_PERIPH(PWMx));
886  assert_param(IS_PWM_DB_IN(PWM_DB_InitStruct->PWM_DB_In));
887  assert_param(IS_PWM_DB_POL(PWM_DB_InitStruct->PWM_DB_Pol));
888  assert_param(IS_PWM_DB_OUT(PWM_DB_InitStruct->PWM_DB_Out));
889 
890  PWMx->DBCTL_bit.IN_MODE = (uint32_t)PWM_DB_InitStruct->PWM_DB_In;
891  PWMx->DBCTL_bit.POLSEL = (uint32_t)PWM_DB_InitStruct->PWM_DB_Pol;
892  PWMx->DBCTL_bit.OUT_MODE = (uint32_t)PWM_DB_InitStruct->PWM_DB_Out;
893 
894  PWM_DB_SetRiseDelay(PWMx, PWM_DB_InitStruct->PWM_DB_RiseDelay);
895  PWM_DB_SetFallDelay(PWMx, PWM_DB_InitStruct->PWM_DB_FallDelay);
896 }
897 
905 void PWM_DB_StructInit(PWM_DB_Init_TypeDef* PWM_DB_InitStruct)
906 {
907  PWM_DB_InitStruct->PWM_DB_In = PWM_DB_In_A;
908  PWM_DB_InitStruct->PWM_DB_Pol = PWM_DB_Pol_ActHigh;
909  PWM_DB_InitStruct->PWM_DB_Out = PWM_DB_Out_BypassAB;
910  PWM_DB_InitStruct->PWM_DB_RiseDelay = 0;
911  PWM_DB_InitStruct->PWM_DB_FallDelay = 0;
912 }
913 
921 void PWM_DB_SetRiseDelay(NT_PWM_TypeDef* PWMx, uint32_t RiseDelayVal)
922 {
923  assert_param(IS_PWM_ALL_PERIPH(PWMx));
924  assert_param(IS_PWM_DB_DELAY_VAL(RiseDelayVal));
925 
926  PWMx->DBRED = RiseDelayVal;
927 }
928 
936 void PWM_DB_SetFallDelay(NT_PWM_TypeDef* PWMx, uint32_t FallDelayVal)
937 {
938  assert_param(IS_PWM_ALL_PERIPH(PWMx));
939  assert_param(IS_PWM_DB_DELAY_VAL(FallDelayVal));
940 
941  PWMx->DBFED = FallDelayVal;
942 }
943 
950 uint32_t PWM_DB_GetRiseDelay(NT_PWM_TypeDef* PWMx)
951 {
952  assert_param(IS_PWM_ALL_PERIPH(PWMx));
953 
954  return PWMx->DBRED;
955 }
956 
963 uint32_t PWM_DB_GetFallDelay(NT_PWM_TypeDef* PWMx)
964 {
965  assert_param(IS_PWM_ALL_PERIPH(PWMx));
966 
967  return PWMx->DBFED;
968 }
969 
979 void PWM_FilterConfig(NT_PWM_TypeDef* PWMx, uint32_t FilterVal)
980 {
981  assert_param(IS_PWM_ALL_PERIPH(PWMx));
982  assert_param(IS_PWM_FILTER(FilterVal));
983 
984  PWMx->FWDTH = FilterVal;
985 }
986 
1002 void PWM_PC_Config(NT_PWM_TypeDef* PWMx, uint32_t DutyVal, uint32_t FreqDivVal, uint32_t FirstWidthVal)
1003 {
1004  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1005  assert_param(IS_PWM_PC_DUTY(DutyVal));
1006  assert_param(IS_PWM_PC_FREQ_DIV(FreqDivVal));
1007  assert_param(IS_PWM_PC_FIRST_WIDTH(FirstWidthVal));
1008 
1009  PWMx->PCCTL_bit.CHPDUTY = DutyVal;
1010  PWMx->PCCTL_bit.SHRFREQ = FreqDivVal;
1011  PWMx->PCCTL_bit.OSHTWTH = FirstWidthVal;
1012 }
1013 
1022 void PWM_PC_Cmd(NT_PWM_TypeDef* PWMx, FunctionalState State)
1023 {
1024  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1025  assert_param(IS_FUNCTIONAL_STATE(State));
1026 
1027  PWMx->PCCTL_bit.CHPEN = (uint32_t)State;
1028 }
1029 
1040 void PWM_TZ_ActionConfig(NT_PWM_TypeDef* PWMx, PWM_TZ_Action_TypeDef TZ_ActionA, PWM_TZ_Action_TypeDef TZ_ActionB)
1041 {
1042  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1043  assert_param(IS_PWM_TZ_ACTION(TZ_ActionA));
1044  assert_param(IS_PWM_TZ_ACTION(TZ_ActionB));
1045 
1046  PWMx->TZCTL_bit.TZA = (uint32_t)TZ_ActionA;
1047  PWMx->TZCTL_bit.TZB = (uint32_t)TZ_ActionB;
1048 }
1049 
1060 void PWM_TZ_CycleCmd(NT_PWM_TypeDef* PWMx, uint32_t TZ_Channel, FunctionalState State)
1061 {
1062  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1063  assert_param(IS_PWM_TZ_CHANNEL(TZ_Channel));
1064  assert_param(IS_FUNCTIONAL_STATE(State));
1065 
1066  if (State == ENABLE)
1067  {
1068  PWMx->TZSEL |= (uint32_t)TZ_Channel;
1069  }
1070  else
1071  {
1072  PWMx->TZSEL &= ~(uint32_t)TZ_Channel;
1073  }
1074 }
1075 
1086 void PWM_TZ_OneShotCmd(NT_PWM_TypeDef* PWMx, uint32_t TZ_Channel, FunctionalState State)
1087 {
1088  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1089  assert_param(IS_PWM_TZ_CHANNEL(TZ_Channel));
1090  assert_param(IS_FUNCTIONAL_STATE(State));
1091 
1092  if (State == ENABLE)
1093  {
1094  PWMx->TZSEL |= ((uint32_t)TZ_Channel << 8);
1095  }
1096  else
1097  {
1098  PWMx->TZSEL &= ~((uint32_t)TZ_Channel << 8);
1099  }
1100 }
1101 
1112 void PWM_TZ_ITCmd(NT_PWM_TypeDef* PWMx, uint32_t TZ_ITSource, FunctionalState State)
1113 {
1114  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1115  assert_param(IS_PWM_TZ_IT_SOURCE(TZ_ITSource));
1116  assert_param(IS_FUNCTIONAL_STATE(State));
1117 
1118  if (State == ENABLE)
1119  {
1120  PWMx->TZEINT |= (uint32_t)TZ_ITSource;
1121  }
1122  else
1123  {
1124  PWMx->TZEINT &= ~(uint32_t)TZ_ITSource;
1125  }
1126 }
1127 
1137 FlagStatus PWM_TZ_ITStatus(NT_PWM_TypeDef* PWMx, uint32_t TZ_ITStatus)
1138 {
1139  FlagStatus Status;
1140 
1141  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1142  assert_param(IS_PWM_TZ_IT_STATUS(TZ_ITStatus));
1143 
1144  if (PWMx->TZFLG & TZ_ITStatus)
1145  {
1146  Status = Flag_SET;
1147  }
1148  else
1149  {
1150  Status = Flag_CLEAR;
1151  }
1152 
1153  return Status;
1154 }
1155 
1164 void PWM_TZ_ITStatusClear(NT_PWM_TypeDef* PWMx, uint32_t TZ_ITStatus)
1165 {
1166  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1167  assert_param(IS_PWM_TZ_IT_STATUS(TZ_ITStatus));
1168 
1169  PWMx->TZCLR = TZ_ITStatus;
1170 }
1171 
1178 FlagStatus PWM_TZ_ITPendStatus(NT_PWM_TypeDef* PWMx)
1179 {
1180  FlagStatus Status;
1181 
1182  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1183 
1184  if (PWMx->TZINTCLR_bit.TZINT)
1185  {
1186  Status = Flag_SET;
1187  }
1188  else
1189  {
1190  Status = Flag_CLEAR;
1191  }
1192 
1193  return Status;
1194 }
1195 
1202 void PWM_TZ_ITPendClear(NT_PWM_TypeDef* PWMx)
1203 {
1204  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1205 
1206  PWMx->TZINTCLR_bit.TZINT = 1;
1207 }
1208 
1217 void PWM_TZ_ITForce(NT_PWM_TypeDef* PWMx, uint32_t TZ_ITSource)
1218 {
1219  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1220  assert_param(IS_PWM_TZ_IT_SOURCE(TZ_ITSource));
1221 
1222  PWMx->TZFRC = TZ_ITSource;
1223 }
1224 
1233 void PWM_ET_Init(NT_PWM_TypeDef* PWMx, PWM_ET_Init_TypeDef* PWM_ET_InitStruct)
1234 {
1235  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1236  assert_param(IS_PWM_EVENT(PWM_ET_InitStruct->PWM_ET_Event_A));
1237  assert_param(IS_PWM_ET_PERIOD(PWM_ET_InitStruct->PWM_ET_Period_A));
1238  assert_param(IS_PWM_EVENT(PWM_ET_InitStruct->PWM_ET_Event_B));
1239  assert_param(IS_PWM_ET_PERIOD(PWM_ET_InitStruct->PWM_ET_Period_B));
1240 
1241  PWMx->ETSEL_bit.SOCASEL = (uint32_t)PWM_ET_InitStruct->PWM_ET_Event_A;
1242  PWMx->ETSEL_bit.SOCBSEL = (uint32_t)PWM_ET_InitStruct->PWM_ET_Event_B;
1243 
1244  PWMx->ETPS_bit.SOCAPRD = PWM_ET_InitStruct->PWM_ET_Period_A;
1245  PWMx->ETPS_bit.SOCBPRD = PWM_ET_InitStruct->PWM_ET_Period_B;
1246 }
1247 
1255 void PWM_ET_StructInit(PWM_ET_Init_TypeDef* PWM_ET_InitStruct)
1256 {
1257  PWM_ET_InitStruct->PWM_ET_Event_A = PWM_Event_None;
1258  PWM_ET_InitStruct->PWM_ET_Event_B = PWM_Event_None;
1259  PWM_ET_InitStruct->PWM_ET_Period_A = 0;
1260  PWM_ET_InitStruct->PWM_ET_Period_B = 0;
1261 }
1262 
1273 void PWM_ET_Cmd(NT_PWM_TypeDef* PWMx, PWM_ET_Channel_TypeDef ET_Channel, FunctionalState State)
1274 {
1275  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1276  assert_param(IS_PWM_ET_CHANNEL(ET_Channel));
1277  assert_param(IS_FUNCTIONAL_STATE(State));
1278 
1279  if (ET_Channel == PWM_ET_Channel_A)
1280  {
1281  PWMx->ETSEL_bit.SOCAEN = (uint32_t)State;
1282  }
1283  else /* if (ET_Channel == PWM_ET_Channel_B) */
1284  {
1285  PWMx->ETSEL_bit.SOCBEN = (uint32_t)State;
1286  }
1287 }
1288 
1295 uint32_t PWM_ET_GetEventCount(NT_PWM_TypeDef* PWMx, PWM_ET_Channel_TypeDef ET_Channel)
1296 {
1297  uint32_t EventCount;
1298 
1299  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1300  assert_param(IS_PWM_ET_CHANNEL(ET_Channel));
1301 
1302  if (ET_Channel == PWM_ET_Channel_A)
1303  {
1304  EventCount = PWMx->ETPS_bit.SOCACNT;
1305  }
1306  else /* if (ET_Channel == PWM_ET_Channel_B) */
1307  {
1308  EventCount = PWMx->ETPS_bit.SOCBCNT;
1309  }
1310 
1311  return EventCount;
1312 }
1313 
1323 FlagStatus PWM_ET_Status(NT_PWM_TypeDef* PWMx, uint32_t ET_Status)
1324 {
1325  FlagStatus Status;
1326 
1327  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1328  assert_param(IS_PWM_ET_STATUS(ET_Status));
1329 
1330  if (PWMx->ETFLG & ET_Status)
1331  {
1332  Status = Flag_SET;
1333  }
1334  else
1335  {
1336  Status = Flag_CLEAR;
1337  }
1338 
1339  return Status;
1340 }
1341 
1350 void PWM_ET_StatusClear(NT_PWM_TypeDef* PWMx, uint32_t ET_Status)
1351 {
1352  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1353  assert_param(IS_PWM_ET_STATUS(ET_Status));
1354 
1355  PWMx->ETCLR = ET_Status;
1356 }
1357 
1366 void PWM_ET_Force(NT_PWM_TypeDef* PWMx, uint32_t ET_Status)
1367 {
1368  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1369  assert_param(IS_PWM_ET_STATUS(ET_Status));
1370 
1371  PWMx->ETFRC = ET_Status;
1372 }
1373 
1384 void PWM_HD_ActionConfig(NT_PWM_TypeDef* PWMx, PWM_HD_Action_TypeDef HD_ActionA, PWM_HD_Action_TypeDef HD_ActionB)
1385 {
1386  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1387  assert_param(IS_PWM_HD_ACTION(HD_ActionA));
1388  assert_param(IS_PWM_HD_ACTION(HD_ActionB));
1389 
1390  PWMx->HDCTL_bit.HDA = (uint32_t)HD_ActionA;
1391  PWMx->HDCTL_bit.HDB = (uint32_t)HD_ActionB;
1392 }
1393 
1404 void PWM_HD_ChannelCmd(NT_PWM_TypeDef* PWMx, uint32_t HD_Channel, FunctionalState State)
1405 {
1406  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1407  assert_param(IS_PWM_HD_CHANNEL(HD_Channel));
1408  assert_param(IS_FUNCTIONAL_STATE(State));
1409 
1410  if (State == ENABLE)
1411  {
1412  PWMx->HDSEL |= (uint32_t)HD_Channel;
1413  }
1414  else
1415  {
1416  PWMx->HDSEL &= ~(uint32_t)HD_Channel;
1417  }
1418 }
1419 
1428 void PWM_HD_CycleCmd(NT_PWM_TypeDef* PWMx, FunctionalState State)
1429 {
1430  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1431  assert_param(IS_FUNCTIONAL_STATE(State));
1432 
1433  PWMx->HDSEL_bit.CBC = (uint32_t)State;
1434 }
1435 
1444 void PWM_HD_OneShotCmd(NT_PWM_TypeDef* PWMx, FunctionalState State)
1445 {
1446  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1447  assert_param(IS_FUNCTIONAL_STATE(State));
1448 
1449  PWMx->HDSEL_bit.OSHT = (uint32_t)State;
1450 }
1451 
1462 void PWM_HD_ITCmd(NT_PWM_TypeDef* PWMx, uint32_t HD_ITSource, FunctionalState State)
1463 {
1464  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1465  assert_param(IS_PWM_HD_IT_SOURCE(HD_ITSource));
1466  assert_param(IS_FUNCTIONAL_STATE(State));
1467 
1468  if (State == ENABLE)
1469  {
1470  PWMx->HDEINT |= (uint32_t)HD_ITSource;
1471  }
1472  else
1473  {
1474  PWMx->HDEINT &= ~(uint32_t)HD_ITSource;
1475  }
1476 }
1477 
1487 FlagStatus PWM_HD_ITStatus(NT_PWM_TypeDef* PWMx, uint32_t HD_ITStatus)
1488 {
1489  FlagStatus Status;
1490 
1491  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1492  assert_param(IS_PWM_HD_IT_STATUS(HD_ITStatus));
1493 
1494  if (PWMx->HDFLG & HD_ITStatus)
1495  {
1496  Status = Flag_SET;
1497  }
1498  else
1499  {
1500  Status = Flag_CLEAR;
1501  }
1502 
1503  return Status;
1504 }
1505 
1514 void PWM_HD_ITStatusClear(NT_PWM_TypeDef* PWMx, uint32_t HD_ITStatus)
1515 {
1516  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1517  assert_param(IS_PWM_TZ_IT_STATUS(HD_ITStatus));
1518 
1519  PWMx->HDCLR = HD_ITStatus;
1520 }
1521 
1528 FlagStatus PWM_HD_ITPendStatus(NT_PWM_TypeDef* PWMx)
1529 {
1530  FlagStatus Status;
1531 
1532  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1533 
1534  if (PWMx->HDINTCLR_bit.HDINT)
1535  {
1536  Status = Flag_SET;
1537  }
1538  else
1539  {
1540  Status = Flag_CLEAR;
1541  }
1542 
1543  return Status;
1544 }
1545 
1552 void PWM_HD_ITPendClear(NT_PWM_TypeDef* PWMx)
1553 {
1554  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1555 
1556  PWMx->HDINTCLR_bit.HDINT = 1;
1557 }
1558 
1567 void PWM_HD_ITForce(NT_PWM_TypeDef* PWMx, uint32_t HD_ITSource)
1568 {
1569  assert_param(IS_PWM_ALL_PERIPH(PWMx));
1570  assert_param(IS_PWM_HD_IT_SOURCE(HD_ITSource));
1571 
1572  PWMx->HDFRC = HD_ITSource;
1573 }
1574 
1591 /******************* (C) COPYRIGHT 2016 NIIET *****END OF FILE****/
#define IS_PWM_FILTER(FILTER)
Макрос проверки ширины фильтрации коротких импульсов на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:905
void PWM_DeInit(NT_PWM_TypeDef *PWMx)
Устанавливает все регистры блока ШИМ значениями по умолчанию.
Definition: niietcm4_pwm.c:131
PWM_ChAction_TypeDef PWM_ChAction_CTREqCMPB_Down_B
Definition: niietcm4_pwm.h:574
uint32_t PWM_HR_GetPhase(NT_PWM_TypeDef *PWMx)
Получение текущего расширенного значения фазы ШИМ высокого разрешения.
Definition: niietcm4_pwm.c:731
PWM_TZ_Action_TypeDef
Выбор поведения вывода в случае наступления сигнала аварии.
Definition: niietcm4_pwm.h:379
#define IS_PWM_HR_CMP_VAL(CMP_VAL)
Проверка значения сравнения на попадание в допустимый диапазон для ШИМ высокого разрешения.
Definition: niietcm4_pwm.h:612
uint32_t PWM_CMP_GetA(NT_PWM_TypeDef *PWMx)
Получение текущего значения сравнения компаратора A ШИМ.
Definition: niietcm4_pwm.c:585
void PWM_CTR_SWSyncInCmd(NT_PWM_TypeDef *PWMx)
Программный запуск входного синхроимпульса SYNCI.
Definition: niietcm4_pwm.c:474
PWM_HR_Edge_TypeDef PWM_HR_Edge
Definition: niietcm4_pwm.h:594
Файл содержит все прототипы функций для блоков ШИМ
PWM_ChAction_TypeDef
Действие на выводе ШИМ.
Definition: niietcm4_pwm.h:268
void PWM_TZ_ITStatusClear(NT_PWM_TypeDef *PWMx, uint32_t TZ_ITStatus)
Сброс флага прерывания от обработчика сигналов аварии выбранного блока ШИМ.
void PWM_ChForceCmd(NT_PWM_TypeDef *PWMx, PWM_Channel_TypeDef Channel)
Применение выбранного однократного программного воздейсвия на канал(ы) PWM.
Definition: niietcm4_pwm.c:254
PWM_CTR_Halt_TypeDef PWM_CTR_Halt
Definition: niietcm4_pwm.h:493
PWM_ChAction_TypeDef PWM_ChAction_CTREqCMPB_Up_B
Definition: niietcm4_pwm.h:572
#define IS_PWM_CLK_DIV(CLK_DIV)
Макрос проверки аргументов типа PWM_ClkDiv_TypeDef.
Definition: niietcm4_pwm.h:129
PWM_ChAction_TypeDef PWM_ChAction_CTREqZero_B
Definition: niietcm4_pwm.h:516
PWM_LoadEvent_TypeDef PWM_LoadEvent_CMPB
Definition: niietcm4_pwm.h:556
void PWM_ET_Force(NT_PWM_TypeDef *PWMx, uint32_t ET_Status)
Программный вызов генерации события запуска АЦП выбранным блоком ШИМ.
void PWM_HR_SetPhase(NT_PWM_TypeDef *PWMx, uint32_t HR_PhaseVal)
Установка расширенного значения фазы ШИМ высокого разрешения.
Definition: niietcm4_pwm.c:704
void PWM_PC_Cmd(NT_PWM_TypeDef *PWMx, FunctionalState State)
Включение модулятора блока ШИМ.
PWM_CTR_Mode_TypeDef PWM_CTR_Mode
Definition: niietcm4_pwm.h:508
void PWM_HR_Init(NT_PWM_TypeDef *PWMx, PWM_HR_Init_TypeDef *PWM_HR_InitStruct)
Инициализирует режим высокого разрешения PWMx согласно параметрам структуры PWM_HR_InitStruct.
Definition: niietcm4_pwm.c:650
#define IS_PWM_HR_EDGE(HR_EDGE)
Макрос проверки аргументов типа PWM_HR_Edge_TypeDef.
Definition: niietcm4_pwm.h:463
void PWM_HD_ITCmd(NT_PWM_TypeDef *PWMx, uint32_t HD_ITSource, FunctionalState State)
Включение прерывания по событию удержания.
PWM_LoadMode_TypeDef PWM_LoadMode_CMPB
Definition: niietcm4_pwm.h:554
PWM_HD_Action_TypeDef
Выбор поведения вывода в случае наступления события удержания.
Definition: niietcm4_pwm.h:472
PWM_ClkDiv_TypeDef PWM_ClkDiv
Definition: niietcm4_pwm.h:495
PWM_ChAction_TypeDef PWM_ChAction_CTREqCMPA_Down_B
Definition: niietcm4_pwm.h:570
#define IS_PWM_CTR_SYNC_OUT(CTR_SYNC_OUT)
Макрос проверки аргументов типа PWM_CTR_SyncOut_TypeDef.
Definition: niietcm4_pwm.h:238
void PWM_SyncConfig(PWM_Sync_TypeDef SyncSelect)
Выбор схемы синхронизации блоков ШИМ.
Definition: niietcm4_pwm.c:118
PWM_ChAction_TypeDef PWM_ChAction_CTREqCMPA_Down_A
Definition: niietcm4_pwm.h:562
void PWM_HR_StructInit(PWM_HR_Init_TypeDef *PWM_HR_InitStruct)
Заполнение каждого члена структуры PWM_HR_InitStruct значениями по умолчанию.
Definition: niietcm4_pwm.c:673
uint32_t PWM_DB_RiseDelay
Definition: niietcm4_pwm.h:632
void PWM_DB_SetFallDelay(NT_PWM_TypeDef *PWMx, uint32_t FallDelayVal)
Установка значения величины задержки по заднему фронту.
Definition: niietcm4_pwm.c:936
void PWM_ITCmd(NT_PWM_TypeDef *PWMx, FunctionalState State)
Разрешение работы прерывания выбранного блока ШИМ.
Definition: niietcm4_pwm.c:767
void PWM_CMP_StructInit(PWM_CMP_Init_TypeDef *PWM_CMP_InitStruct)
Заполнение каждого члена структуры PWM_CMPInitStruct значениями по умолчанию.
Definition: niietcm4_pwm.c:530
#define IS_PWM_CTR_MODE(CTR_MODE)
Макрос проверки аргументов типа PWM_CTR_Mode_TypeDef.
Definition: niietcm4_pwm.h:259
void PWM_CTR_StructInit(PWM_CTR_Init_TypeDef *PWM_CTR_InitStruct)
Заполнение каждого члена структуры PWM_TimerInitStruct значениями по умолчанию.
Definition: niietcm4_pwm.c:323
#define IS_PWM_CTR_HALT(CTR_HALT)
Макрос проверки аргументов типа PWM_CTR_Halt_TypeDef.
Definition: niietcm4_pwm.h:66
#define IS_PWM_LOAD_EVENT(LOAD_EVENT)
Макрос проверки аргументов типа PWM_LoadEvent_TypeDef.
Definition: niietcm4_pwm.h:217
#define IS_PWM_DB_IN(DB_IN)
Макрос проверки аргументов типа PWM_DB_In_TypeDef.
Definition: niietcm4_pwm.h:301
PWM_HR_Mode_TypeDef PWM_HR_Mode
Definition: niietcm4_pwm.h:592
FlagStatus PWM_CTR_Status(NT_PWM_TypeDef *PWMx, uint32_t CTR_Status)
Чтение статуса флага состояния таймера PWM.
Definition: niietcm4_pwm.c:350
uint32_t PWM_CTR_GetPeriod(NT_PWM_TypeDef *PWMx)
Получение текущего значения периода ШИМ.
Definition: niietcm4_pwm.c:449
#define IS_PWM_PC_FREQ_DIV(PC_FREQ_DIV)
Макрос проверки значения делителя частоты второго и последующего импульсов в модуляторе на попадание ...
Definition: niietcm4_pwm.h:917
#define IS_PWM_ET_PERIOD(ET_PERIOD)
Проверка значения количества событий для генерации строба запуска обработчиком событий.
Definition: niietcm4_pwm.h:666
PWM_DB_Out_TypeDef PWM_DB_Out
Definition: niietcm4_pwm.h:630
PWM_ChAction_TypeDef PWM_ChAction_CTREqPeriod_A
Definition: niietcm4_pwm.h:518
FlagStatus PWM_TZ_ITStatus(NT_PWM_TypeDef *PWMx, uint32_t TZ_ITStatus)
Чтение статуса флага прерывания от обработчика сигналов аварии выбранного блока ШИМ.
#define IS_PWM_PC_DUTY(PC_DUTY)
Макрос проверки значения скважности второго и последующего импульсов в модуляторе на попадание в допу...
Definition: niietcm4_pwm.h:911
void PWM_DB_Init(NT_PWM_TypeDef *PWMx, PWM_DB_Init_TypeDef *PWM_DB_InitStruct)
Инициализирует блок &quot;мертвого времени&quot; PWMx согласно параметрам структуры PWM_DB_InitStruct.
Definition: niietcm4_pwm.c:883
uint32_t PWM_DB_GetFallDelay(NT_PWM_TypeDef *PWMx)
Получение текущего значения величины задержки по заднему фронту.
Definition: niietcm4_pwm.c:963
#define IS_PWM_ET_CHANNEL(ET_CHANNEL)
Макрос проверки аргументов типа PWM_ET_Channel_TypeDef.
Definition: niietcm4_pwm.h:410
PWM_ClkDivExtra_TypeDef PWM_ClkDivExtra
Definition: niietcm4_pwm.h:497
PWM_LoadMode_TypeDef PWM_LoadMode_CMPA
Definition: niietcm4_pwm.h:548
PWM_Channel_TypeDef
Каналы ШИМ.
Definition: niietcm4_pwm.h:94
PWM_ChAction_TypeDef PWM_ChAction_CTREqZero_A
Definition: niietcm4_pwm.h:514
#define IS_PWM_DB_POL(DB_POL)
Макрос проверки аргументов типа PWM_DB_Pol_TypeDef.
Definition: niietcm4_pwm.h:322
PWM_ET_Channel_TypeDef
Выбор канала для генерации события запуска.
Definition: niietcm4_pwm.h:400
#define IS_PWM_HR_CMP_LOAD(HR_CMP_LOAD)
Макрос проверки аргументов типа PWM_HR_CMPLoad_TypeDef.
Definition: niietcm4_pwm.h:427
uint32_t PWM_ET_GetEventCount(NT_PWM_TypeDef *PWMx, PWM_ET_Channel_TypeDef ET_Channel)
Получение текущего значения счетчика событий, приводящего к генерации события запуска АЦП...
#define IS_PWM_HD_IT_STATUS(IT_STATUS)
Макрос проверки статусов прерываний блока cобытий удержания на попадание в допустимый диапазон...
Definition: niietcm4_pwm.h:889
#define IS_PWM_PRESC(PRESC)
Макрос проверки выбора предделителей блоков ШИМ на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:732
uint32_t PWM_GetITEventCount(NT_PWM_TypeDef *PWMx)
Получение текущего значения счетчика событий, приводящих к прерыванию.
Definition: niietcm4_pwm.c:781
#define IS_PWM_SYNC(SYNC)
Макрос проверки аргументов типа PWM_Sync_TypeDef.
Definition: niietcm4_pwm.h:85
PWM_DB_Pol_TypeDef PWM_DB_Pol
Definition: niietcm4_pwm.h:628
PWM_CTR_SyncOut_TypeDef PWM_CTR_SyncOut
Definition: niietcm4_pwm.h:500
void PWM_CTR_SetValue(NT_PWM_TypeDef *PWMx, uint32_t CTR_Val)
Установка значения счетчика ШИМ.
Definition: niietcm4_pwm.c:392
Структура инициализации таймера блока ШИМ.
Definition: niietcm4_pwm.h:491
#define IS_PWM_ALL_PERIPH(PERIPH)
Макрос проверки аргументов типа NT_PWM_TypeDef.
Definition: niietcm4.h:255
void PWM_HD_ChannelCmd(NT_PWM_TypeDef *PWMx, uint32_t HD_Channel, FunctionalState State)
Выбор каналов для генерации события удержания.
#define IS_PWM_HD_IT_SOURCE(IT_SOURCE)
Макрос проверки источников прерываний блока cобытий удержания на попадание в допустимый диапазон...
Definition: niietcm4_pwm.h:870
void PWM_ITStatusClear(NT_PWM_TypeDef *PWMx)
Сброс флага прерывания выбранного блока ШИМ.
Definition: niietcm4_pwm.c:818
Структура инициализации задержки сигналов ШИМ (&quot;мертвое время&quot;).
Definition: niietcm4_pwm.h:624
uint32_t PWM_DB_GetRiseDelay(NT_PWM_TypeDef *PWMx)
Получение текущего значения величины задержки по переднему фронту.
Definition: niietcm4_pwm.c:950
void PWM_PC_Config(NT_PWM_TypeDef *PWMx, uint32_t DutyVal, uint32_t FreqDivVal, uint32_t FirstWidthVal)
Настройка модулятора сигналов ШИМ.
PWM_ChAction_TypeDef PWM_ChAction_CTREqCMPA_Up_B
Definition: niietcm4_pwm.h:568
uint32_t PWM_ET_Period_A
Definition: niietcm4_pwm.h:652
void PWM_TZ_OneShotCmd(NT_PWM_TypeDef *PWMx, uint32_t TZ_Channel, FunctionalState State)
Включение однократной обработки сигнала аварии.
void PWM_ET_Init(NT_PWM_TypeDef *PWMx, PWM_ET_Init_TypeDef *PWM_ET_InitStruct)
Инициализирует блок &quot;триггера событий&quot; PWMx, согласно параметрам структуры PWM_ET_InitStruct.
#define IS_PWM_TZ_IT_SOURCE(IT_SOURCE)
Макрос проверки прерываний блока сигналов аварий ШИМ на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:750
void PWM_HD_CycleCmd(NT_PWM_TypeDef *PWMx, FunctionalState State)
Включение циклической обработки сигнала удержания.
PWM_ChAction_TypeDef PWM_ChAction_CTREqCMPB_Down_A
Definition: niietcm4_pwm.h:566
void PWM_ChForceConfig(NT_PWM_TypeDef *PWMx, PWM_Channel_TypeDef Channel, PWM_ChAction_TypeDef ChActionA, PWM_ChAction_TypeDef ChActionB)
Настройка типа однократного программного воздейсвия на канал(ы) PWM.
Definition: niietcm4_pwm.c:224
void PWM_HD_ITPendClear(NT_PWM_TypeDef *PWMx)
Сброс запроса прерывания от обработчика событий удержания выбранного блока ШИМ.
void RCC_PeriphRstCmd(RCC_PeriphRst_TypeDef RCC_PeriphRst, FunctionalState State)
Вывод из состояния сброса периферийных блоков.
Definition: niietcm4_rcc.c:868
#define IS_PWM_CTR_DIR(CTR_DIR)
Макрос проверки аргументов типа PWM_CTR_Dir_TypeDef.
Definition: niietcm4_pwm.h:181
#define IS_PWM_CTR_STATUS(CTR_STATUS)
Макрос проверки статусов таймера на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:689
void PWM_TZ_ITPendClear(NT_PWM_TypeDef *PWMx)
Сброс запроса прерывания от сигнала аварии выбранного блока ШИМ.
PWM_ChAction_TypeDef PWM_ChAction_CTREqCMPA_Up_A
Definition: niietcm4_pwm.h:560
void PWM_ET_StructInit(PWM_ET_Init_TypeDef *PWM_ET_InitStruct)
Заполнение каждого члена структуры PWM_ET_InitStruct значениями по умолчанию.
Структура инициализации блока &quot;триггера событий&quot; для запуска измерений АЦП.
Definition: niietcm4_pwm.h:648
PWM_ChAction_TypeDef PWM_ChAction_CTREqCMPB_Up_A
Definition: niietcm4_pwm.h:564
#define IS_PWM_DB_OUT(DB_OUT)
Макрос проверки аргументов типа PWM_DB_Out_TypeDef.
Definition: niietcm4_pwm.h:343
#define IS_PWM_CMP_STATUS(CMP_STATUS)
Макрос проверки статусов компаратора на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:707
void PWM_DB_StructInit(PWM_DB_Init_TypeDef *PWM_DB_InitStruct)
Заполнение каждого члена структуры PWM_DB_InitStruct значениями по умолчанию.
Definition: niietcm4_pwm.c:905
PWM_Sync_TypeDef
Выбор схемы синхронизации модулей ШИМ.
Definition: niietcm4_pwm.h:73
#define IS_PWM_CHANNEL(CHANNEL)
Макрос проверки аргументов типа PWM_Channel_TypeDef.
Definition: niietcm4_pwm.h:105
#define IS_PWM_HD_ACTION(HD_ACTION)
Макрос проверки аргументов типа PWM_HD_Action_TypeDef.
Definition: niietcm4_pwm.h:483
void PWM_ChForceContCmd(NT_PWM_TypeDef *PWMx, PWM_Channel_TypeDef Channel, PWM_ChAction_TypeDef ChActionA, PWM_ChAction_TypeDef ChActionB)
Программное задание продолжительного воздейсвия на канал(ы) PWM.
Definition: niietcm4_pwm.c:190
#define IS_PWM_COUNTER_VAL(COUNTER_VAL)
Проверка значения таймера на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:540
void PWM_ET_Cmd(NT_PWM_TypeDef *PWMx, PWM_ET_Channel_TypeDef ET_Channel, FunctionalState State)
Включение генерации строба запуска АЦП по событию.
PWM_Event_TypeDef PWM_ET_Event_A
Definition: niietcm4_pwm.h:650
#define IS_PWM_LOAD_MODE(LOAD_MODE)
Макрос проверки аргументов типа PWM_LoadMode_TypeDef.
Definition: niietcm4_pwm.h:198
#define IS_PWM_EVENT(EVENT)
Макрос проверки аргументов типа PWM_Event_TypeDef.
Definition: niietcm4_pwm.h:367
FunctionalState PWM_PhaseEn
Definition: niietcm4_pwm.h:502
#define IS_PWM_HD_CHANNEL(HD_CHANNEL)
Макрос проверки источника события удержания на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:852
void PWM_TZ_ITForce(NT_PWM_TypeDef *PWMx, uint32_t TZ_ITSource)
Программный вызов прерывания от сигнала аварии выбранного блока ШИМ.
#define IS_PWM_PERIOD_VAL(PERIOD_VAL)
Проверка значения периода на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:534
#define IS_PWM_DB_DELAY_VAL(DB_DELAY_VAL)
Проверка значения величины задержки фронта в блоке &quot;мертвого времени&quot;.
Definition: niietcm4_pwm.h:642
FlagStatus PWM_ET_Status(NT_PWM_TypeDef *PWMx, uint32_t ET_Status)
Чтение статуса флага генерации события запуска АЦП выбранным блоком ШИМ.
PWM_Event_TypeDef
Возможные события для генерации внешних сигналов.
Definition: niietcm4_pwm.h:352
#define IS_PWM_HR_ALL_PERIPH(PERIPH)
Макрос проверки аргументов типа NT_PWM_TypeDef, в которых доустпен режим высокого разрешения...
Definition: niietcm4.h:269
uint32_t PWM_CTR_GetValue(NT_PWM_TypeDef *PWMx)
Получение текущего значения счетчика ШИМ.
Definition: niietcm4_pwm.c:436
Структура инициализации компараторов блока ШИМ.
Definition: niietcm4_pwm.h:546
#define IS_PWM_TZ_CHANNEL(TZ_CHANNEL)
Макрос проверки номера сигнала аварии на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:791
void PWM_CMP_Init(NT_PWM_TypeDef *PWMx, PWM_CMP_Init_TypeDef *PWM_CMP_InitStruct)
Инициализирует компараторы PWMx согласно параметрам структуры PWM_CMP_InitStruct. ...
Definition: niietcm4_pwm.c:489
#define IS_PWM_CLK_DIV_EXTRA(CLK_DIV_EXTRA)
Макрос проверки аргументов типа PWM_ClkDivExtra_TypeDef.
Definition: niietcm4_pwm.h:158
FlagStatus
Описывает возможные состояния флага при запросе его статуса.
Definition: niietcm4.h:195
uint32_t PWM_DB_FallDelay
Definition: niietcm4_pwm.h:634
void PWM_CTR_StatusClear(NT_PWM_TypeDef *PWMx, uint32_t CTR_Status)
Сброс флагов статусов таймера PWM.
Definition: niietcm4_pwm.c:377
#define IS_PWM_CMP_VAL(CMP_VAL)
Проверка значения сравнения на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:582
PWM_Event_TypeDef PWM_ET_Event_B
Definition: niietcm4_pwm.h:655
PWM_CTR_Dir_TypeDef PWM_CTR_Dir_Phase
Definition: niietcm4_pwm.h:504
FunctionalState
Описывает логическое состояние периферии. Используется для операций включения/выключения периферийных...
Definition: niietcm4.h:169
void PWM_ITConfig(NT_PWM_TypeDef *PWMx, PWM_Event_TypeDef Event, uint32_t ITPeriod)
Настройка прерывания ШИМ.
Definition: niietcm4_pwm.c:749
FlagStatus PWM_ITPendStatus(NT_PWM_TypeDef *PWMx)
Чтение статуса запроса прерывания выбранного блока ШИМ.
Definition: niietcm4_pwm.c:831
void PWM_CMP_SetA(NT_PWM_TypeDef *PWMx, uint32_t CMPAVal)
Установка значения сравнения компаратора A ШИМ.
Definition: niietcm4_pwm.c:556
#define IS_PWM_ET_STATUS(ET_STATUS)
Макрос проверки событий запуска АЦП обработчиком событий на попадание в допустимый диапазон...
Definition: niietcm4_pwm.h:809
FlagStatus PWM_ITStatus(NT_PWM_TypeDef *PWMx)
Чтение статуса флага прерывания выбранного блока ШИМ.
Definition: niietcm4_pwm.c:794
PWM_DB_In_TypeDef PWM_DB_In
Definition: niietcm4_pwm.h:626
RCC_PeriphRst_TypeDef
Управление сбросом периферийных блоков
Definition: niietcm4_rcc.h:295
#define IS_PWM_HR_MODE(HR_MODE)
Макрос проверки аргументов типа PWM_HR_Mode_TypeDef.
Definition: niietcm4_pwm.h:444
void PWM_TZ_ActionConfig(NT_PWM_TypeDef *PWMx, PWM_TZ_Action_TypeDef TZ_ActionA, PWM_TZ_Action_TypeDef TZ_ActionB)
Настройка поведения канала при поступлении сигнала аварии.
#define IS_FUNCTIONAL_STATE(STATE)
Макрос проверки аргументов типа FunctionalState.
Definition: niietcm4.h:179
void PWM_PrescCmd(uint32_t Presc, FunctionalState State)
Управление предделителями тактирования таймеров блоков ШИМ.
Definition: niietcm4_pwm.c:96
void PWM_CTR_SetPhase(NT_PWM_TypeDef *PWMx, uint32_t CTR_PhaseVal)
Установка значения фазы ШИМ.
Definition: niietcm4_pwm.c:422
uint32_t PWM_ET_Period_B
Definition: niietcm4_pwm.h:657
uint32_t PWM_HR_GetCMP(NT_PWM_TypeDef *PWMx)
Получение текущего расширенного значения сравнения ШИМ высокого разрешения.
Definition: niietcm4_pwm.c:718
void PWM_ITForce(NT_PWM_TypeDef *PWMx)
Программный вызов прерывания выбранного блока ШИМ.
Definition: niietcm4_pwm.c:868
#define IS_PWM_PC_FIRST_WIDTH(PC_FIRST_WIDTH)
Макрос проверки значения ширины первого импульса в модуляторе на попадание в допустимый диапазон...
Definition: niietcm4_pwm.h:923
PWM_LoadMode_TypeDef PWM_LoadMode_Period
Definition: niietcm4_pwm.h:510
void PWM_HD_OneShotCmd(NT_PWM_TypeDef *PWMx, FunctionalState State)
Включение однократной обработки сигнала удержания.
#define IS_PWM_TZ_ACTION(TZ_ACTION)
Макрос проверки аргументов типа PWM_TZ_Action_TypeDef.
Definition: niietcm4_pwm.h:391
void PWM_TZ_CycleCmd(NT_PWM_TypeDef *PWMx, uint32_t TZ_Channel, FunctionalState State)
Включение циклической обработки сигнала аварии.
PWM_HR_CMPLoad_TypeDef PWM_HR_CMPLoad
Definition: niietcm4_pwm.h:590
FlagStatus PWM_CMP_Status(NT_PWM_TypeDef *PWMx, uint32_t CMP_Status)
Чтение статуса флага состояния компараторов PWM. Флаги установлены, если произошла запись в активный ...
Definition: niietcm4_pwm.c:616
void PWM_CMP_SetB(NT_PWM_TypeDef *PWMx, uint32_t CMPBVal)
Установка значения сравнения компаратора B ШИМ.
Definition: niietcm4_pwm.c:571
#define IS_PWM_CH_ACTION(CH_ACTION)
Макрос проверки аргументов типа PWM_ChAction_TypeDef.
Definition: niietcm4_pwm.h:280
void PWM_ITPendClear(NT_PWM_TypeDef *PWMx)
Сброс запроса прерывания выбранного блока ШИМ.
Definition: niietcm4_pwm.c:855
#define IS_PWM_HR_PHASE_VAL(PHASE_VAL)
Проверка значения фазы на попадание в допустимый диапазон для ШИМ высокого разрешения.
Definition: niietcm4_pwm.h:618
void PWM_CTR_Init(NT_PWM_TypeDef *PWMx, PWM_CTR_Init_TypeDef *PWM_CTR_InitStruct)
Инициализирует таймер PWMx согласно параметрам структуры PWM_TimerInitStruct.
Definition: niietcm4_pwm.c:282
void PWM_HD_ITForce(NT_PWM_TypeDef *PWMx, uint32_t HD_ITSource)
Программный вызов прерывания от обработчика событий удержания выбранного блока ШИМ.
uint32_t PWM_CMP_GetB(NT_PWM_TypeDef *PWMx)
Получение текущего значения сравнения компаратора B ШИМ.
Definition: niietcm4_pwm.c:598
void PWM_HD_ActionConfig(NT_PWM_TypeDef *PWMx, PWM_HD_Action_TypeDef HD_ActionA, PWM_HD_Action_TypeDef HD_ActionB)
Настройка поведения канала при поступлении события удержания.
void PWM_TZ_ITCmd(NT_PWM_TypeDef *PWMx, uint32_t TZ_ITSource, FunctionalState State)
Включение прерывания по сигналу аварии.
void PWM_ET_StatusClear(NT_PWM_TypeDef *PWMx, uint32_t ET_Status)
Сброс флага генерации события запуска АЦП выбранным блоком ШИМ.
Структура инициализации режима высокого разрешения блока ШИМ.
Definition: niietcm4_pwm.h:588
uint32_t PWM_CTR_GetPhase(NT_PWM_TypeDef *PWMx)
Получение текущего значения фазы ШИМ.
Definition: niietcm4_pwm.c:462
void PWM_DB_SetRiseDelay(NT_PWM_TypeDef *PWMx, uint32_t RiseDelayVal)
Установка значения величины задержки по переднему фронту.
Definition: niietcm4_pwm.c:921
FlagStatus PWM_TZ_ITPendStatus(NT_PWM_TypeDef *PWMx)
Чтение статуса запроса прерывания от сигнала аварии выбранного блока ШИМ.
void PWM_HR_SetCMP(NT_PWM_TypeDef *PWMx, uint32_t HR_CMPVal)
Установка расширенного значения сравнения компаратора A ШИМ высокого разрешения.
Definition: niietcm4_pwm.c:689
#define IS_PWM_IT_PERIOD(IT_PERIOD)
Макрос проверки количества событий для возникновения прерывания на попадание в допустимый диапазон...
Definition: niietcm4_pwm.h:899
FlagStatus PWM_HD_ITPendStatus(NT_PWM_TypeDef *PWMx)
Чтение статуса запроса прерывания от обработчика событий удержания выбранного блока ШИМ...
PWM_LoadEvent_TypeDef PWM_LoadEvent_CMPA
Definition: niietcm4_pwm.h:550
#define IS_PWM_TZ_IT_STATUS(IT_STATUS)
Макрос проверки прерываний блока сигналов аварий ШИМ на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:769
void PWM_HD_ITStatusClear(NT_PWM_TypeDef *PWMx, uint32_t HD_ITStatus)
Сброс флага прерывания от обработчика событий удержания выбранного блока ШИМ.
void PWM_FilterConfig(NT_PWM_TypeDef *PWMx, uint32_t FilterVal)
Установка ширины фильтрации коротких импульсов.
Definition: niietcm4_pwm.c:979
void PWM_CTR_SetPeriod(NT_PWM_TypeDef *PWMx, uint32_t CTR_PeriodVal)
Установка значения периода ШИМ.
Definition: niietcm4_pwm.c:407
#define IS_PWM_PHASE_VAL(PHASE_VAL)
Проверка значения фазы на попадание в допустимый диапазон.
Definition: niietcm4_pwm.h:528
FlagStatus PWM_HD_ITStatus(NT_PWM_TypeDef *PWMx, uint32_t HD_ITStatus)
Чтение статуса флага прерывания от обработчика событий удержания выбранного блока ШИМ...
PWM_ChAction_TypeDef PWM_ChAction_CTREqPeriod_B
Definition: niietcm4_pwm.h:520