NIIETCM4 PD  v0.10.5
Драйвер периферии для микроконтроллеров на базе ядра ARM Cortex-M4
 Указатель Структуры данных Файлы Функции Переменные Перечисления Элементы перечислений Группы Страницы
niietcm4_rcc.c
См. документацию.
1 
30 /* Includes ------------------------------------------------------------------*/
31 #include "niietcm4_rcc.h"
32 
54 #define RCC_PLL_REF_FREQ ((uint32_t)1000000)
55 #define RCC_PLL_DIV_EN_FREQ ((uint32_t)60000000)
65 #define RCC_PLL_CTRL_Reset_Value ((uint32_t)0x00000000)
66 #define RCC_PLL_OD_Reset_Value ((uint32_t)0x00000000)
67 #define RCC_PLL_NR_Reset_Value ((uint32_t)0x00000000)
68 #define RCC_PLL_NF_Reset_Value ((uint32_t)0x00000000)
88 static uint32_t RCC_WaitClkChange(RCC_SysClk_TypeDef RCC_SysClk)
89 {
90  uint32_t timeout = RCC_CLK_CHANGE_TIMEOUT;
91 
92  while(timeout)
93  {
94  if ((RCC_SysClk_TypeDef)(NT_COMMON_REG->SYS_CLK_bit.CURR_SRC) == RCC_SysClk)
95  {
96  break;
97  }
98  else
99  {
100  timeout--;
101  }
102  }
103 
104  return timeout;
105 }
106 
118 {
119  /* Check the parameters */
120  assert_param(IS_FUNCTIONAL_STATE(State));
121 
122  GPIO_Init_TypeDef GPIO_Init_Struct;
123 
124  GPIO_StructInit(&GPIO_Init_Struct);
125 
126  GPIO_Init_Struct.GPIO_Pin = GPIO_Pin_0;
127  if (State == ENABLE)
128  {
129  GPIO_Init_Struct.GPIO_Dir = GPIO_Dir_Out;
130  GPIO_Init_Struct.GPIO_AltFunc = GPIO_AltFunc_2;
131  GPIO_Init_Struct.GPIO_Mode = GPIO_Mode_AltFunc;
132  GPIO_Init_Struct.GPIO_Out = GPIO_Out_En;
133  }
134 
135  GPIO_Init(NT_GPIOH, &GPIO_Init_Struct);
136 }
137 
154 {
155  uint32_t f_in = 0;
156  uint32_t nf, nr;
158  uint32_t pll_div = 0;
159  OperationStatus status;
160  RCC_PLLInit_TypeDef RCC_PLLInit_Struct;
161  FunctionalState pll_div_cmd = DISABLE;
162  volatile uint32_t pll_stable_wait = RCC_CLK_PLL_STABLE_TIMEOUT;
163 
164  /* Check the parameters */
165  assert_param(IS_RCC_PLL_REF(RCC_PLLRef));
166  assert_param(IS_RCC_SYS_FREQ(SysFreq));
167 
168  if (RCC_PLLRef == RCC_PLLRef_XI_OSC)
169  {
170  f_in = EXT_OSC_VALUE;
171  }
172  else if (RCC_PLLRef == RCC_PLLRef_USB_CLK)
173  {
174  if (NT_COMMON_REG->USB_CTRL_bit.FSEL)
175  {
176  f_in = (uint32_t)(24000000);
177  }
178  else
179  {
180  f_in = (uint32_t)(12000000);
181  }
182  }
183  else if (RCC_PLLRef == RCC_PLLRef_USB_60MHz)
184  {
185  f_in = (uint32_t)(60000000);
186  }
187  else if (RCC_PLLRef == RCC_PLLRef_ETH_25MHz)
188  {
189  f_in = (uint32_t)(25000000);
190  }
191 
192  no = RCC_PLLNO_Div4;
193  if ((SysFreq < RCC_PLL_DIV_EN_FREQ))
194  {
195  pll_div = (RCC_PLL_DIV_EN_FREQ/SysFreq + 1)/2 - 1;
196  pll_div_cmd = ENABLE;
197  }
198 
199  nr = f_in/(2*RCC_PLL_REF_FREQ);
200  if (pll_div_cmd == DISABLE)
201  {
202  nf = ((SysFreq/RCC_PLL_REF_FREQ) * ((uint32_t)no + 1) * nr )/(f_in/RCC_PLL_REF_FREQ);
203  }
204  else /* (pll_div_cmd == ENABLE) */
205  {
206  nf = ((SysFreq/RCC_PLL_REF_FREQ) * ((uint32_t)no + 1) * nr * 2*(pll_div+1) )/(f_in/RCC_PLL_REF_FREQ);
207  }
208 
209 
210  RCC_PLLInit_Struct.RCC_PLLRef = RCC_PLLRef;
211  RCC_PLLInit_Struct.RCC_PLLDiv = pll_div;
212  RCC_PLLInit_Struct.RCC_PLLNO = no;
213  RCC_PLLInit_Struct.RCC_PLLNF = nf;
214  RCC_PLLInit_Struct.RCC_PLLNR = nr;
215 
216  RCC_PLLInit(&RCC_PLLInit_Struct);
217 
218  while(pll_stable_wait)
219  {
220  pll_stable_wait--;
221  }
222 
223  if (pll_div_cmd == DISABLE)
224  {
225  status = RCC_SysClkSel(RCC_SysClk_PLL);
226  }
227  else /* (pll_div_cmd == ENABLE) */
228  {
230  }
231 
232  return status;
233 }
234 
264 void RCC_PLLInit(RCC_PLLInit_TypeDef* RCC_PLLInit_Struct)
265 {
266  assert_param(IS_RCC_PLLDIV(RCC_PLLInit_Struct->RCC_PLLDiv));
267  assert_param(IS_RCC_PLL_NF(RCC_PLLInit_Struct->RCC_PLLNF));
268  assert_param(IS_RCC_PLL_NO(RCC_PLLInit_Struct->RCC_PLLNO));
269  assert_param(IS_RCC_PLL_NR(RCC_PLLInit_Struct->RCC_PLLNR));
270  assert_param(IS_RCC_PLL_REF(RCC_PLLInit_Struct->RCC_PLLRef));
271 
272  NT_COMMON_REG->PLL_CTRL_bit.REFSEL = ((uint32_t)(RCC_PLLInit_Struct->RCC_PLLRef));
273  NT_COMMON_REG->PLL_CTRL_bit.PLL_DIV = RCC_PLLInit_Struct->RCC_PLLDiv;
274  NT_COMMON_REG->PLL_OD = ((uint32_t)(RCC_PLLInit_Struct->RCC_PLLNO));
275  NT_COMMON_REG->PLL_NF = RCC_PLLInit_Struct->RCC_PLLNF - 2;
276  NT_COMMON_REG->PLL_NR = RCC_PLLInit_Struct->RCC_PLLNR - 2;
277 }
278 
286 void RCC_PLLStructInit(RCC_PLLInit_TypeDef* RCC_PLLInit_Struct)
287 {
288  RCC_PLLInit_Struct->RCC_PLLRef = RCC_PLLRef_XI_OSC;
289  RCC_PLLInit_Struct->RCC_PLLDiv = 0;
290  RCC_PLLInit_Struct->RCC_PLLNO = RCC_PLLNO_Disable;
291  RCC_PLLInit_Struct->RCC_PLLNF = 2;
292  RCC_PLLInit_Struct->RCC_PLLNR = 2;
293 }
294 
301 {
302  NT_COMMON_REG->PLL_CTRL = RCC_PLL_CTRL_Reset_Value;
303  NT_COMMON_REG->PLL_OD = RCC_PLL_OD_Reset_Value;
304  NT_COMMON_REG->PLL_NF = RCC_PLL_NF_Reset_Value;
305  NT_COMMON_REG->PLL_NR = RCC_PLL_NR_Reset_Value;
306 }
307 
316 {
317  /* Check the parameters */
318  assert_param(IS_FUNCTIONAL_STATE(State));
319 
320  if (State == DISABLE)
321  {
322  NT_COMMON_REG->PLL_CTRL_bit.PD = 0;
323  }
324  else if (State == ENABLE)
325  {
326  NT_COMMON_REG->PLL_CTRL_bit.PD = 1;
327  }
328 }
329 
345 {
346  /* Check the parameters */
347  assert_param(IS_RCC_PERIPH_CLK(RCC_PeriphClk));
348  assert_param(IS_FUNCTIONAL_STATE(State));
349 
350  if (State == ENABLE)
351  {
352  NT_COMMON_REG->APB_CLK |= RCC_PeriphClk;
353  }
354  else if (State == DISABLE)
355  {
356  NT_COMMON_REG->APB_CLK &= ~RCC_PeriphClk;
357  }
358 }
359 
368 {
369  uint32_t timeout;
370  OperationStatus status;
371 
372  /* Check the parameters */
373  assert_param(IS_RCC_SYS_CLK(RCC_SysClk));
374 
375  NT_COMMON_REG->SYS_CLK = ((uint32_t)RCC_SysClk);
376 
377  timeout = RCC_WaitClkChange(RCC_SysClk);
378 
379  if (timeout)
380  {
381  status = OK;
382  }
383  else
384  {
385  status = ERROR;
386  }
387 
388  return status;
389 }
390 
397 {
398  return((RCC_SysClk_TypeDef)((NT_COMMON_REG->SYS_CLK)>>COMMON_REG_SYS_CLK_CURR_SRC_Pos));
399 }
400 
413 {
414  /* Check the parameters */
415  assert_param(IS_FUNCTIONAL_STATE(State));
416  assert_param(IS_RCC_USB_CLK(RCC_USBClk));
417  assert_param(IS_RCC_USB_FREQ(RCC_USBFreq));
418 
419  static union
420  {
421  __IO uint32_t Value;
422  __IO _COMMON_REG_USB_CTRL_bits Bits;
423  } USB_CTRL_Shadow;
424 
425  USB_CTRL_Shadow.Bits.FSEL = (uint32_t)RCC_USBFreq;
426  USB_CTRL_Shadow.Bits.CLKSEL = (uint32_t)RCC_USBClk;
427  if (State == ENABLE)
428  {
429  USB_CTRL_Shadow.Bits.CLKEN = 1;
430  }
431  else if (State == DISABLE)
432  {
433  USB_CTRL_Shadow.Bits.CLKEN = 0;
434  }
435 
436  NT_COMMON_REG->USB_CTRL = USB_CTRL_Shadow.Value;
437 }
438 
447 void RCC_UARTClkSel(NT_UART_TypeDef* UARTx, RCC_UARTClk_TypeDef RCC_UARTClk)
448 {
449  uint32_t offset;
450 
451  /* Check the parameters */
452  assert_param(IS_UART_ALL_PERIPH(UARTx));
453  assert_param(IS_RCC_UART_CLK(RCC_UARTClk));
454 
455  if (UARTx == NT_UART0)
456  {
457  offset = COMMON_REG_UART_SPI_CLK_SEL_SEL_UART0_Pos;
458  }
459  else if (UARTx == NT_UART1)
460  {
461  offset = COMMON_REG_UART_SPI_CLK_SEL_SEL_UART1_Pos;
462  }
463  else if (UARTx == NT_UART2)
464  {
465  offset = COMMON_REG_UART_SPI_CLK_SEL_SEL_UART2_Pos;
466  }
467  else /* (UARTx == NT_UART3) */
468  {
469  offset = COMMON_REG_UART_SPI_CLK_SEL_SEL_UART3_Pos;
470  }
471 
472  NT_COMMON_REG->UART_SPI_CLK_SEL &= ~(3<<offset);
473  NT_COMMON_REG->UART_SPI_CLK_SEL |= (RCC_UARTClk<<offset);
474 }
475 
487 void RCC_UARTClkDivConfig(NT_UART_TypeDef* UARTx, uint32_t DivVal, FunctionalState DivState)
488 {
489  uint32_t offset;
490 
491  /* Check the parameters */
492  assert_param(IS_UART_ALL_PERIPH(UARTx));
493  assert_param(IS_RCC_CLK_DIV(DivVal));
494  assert_param(IS_FUNCTIONAL_STATE(DivState));
495 
496  if (UARTx == NT_UART0)
497  {
498  offset = COMMON_REG_UART_CLK_DIVEN_UART0_Pos;
499  }
500  else if (UARTx == NT_UART1)
501  {
502  offset = COMMON_REG_UART_CLK_DIVEN_UART1_Pos;
503  }
504  else if (UARTx == NT_UART2)
505  {
506  offset = COMMON_REG_UART_CLK_DIVEN_UART2_Pos;
507  }
508  else /* (UARTx == NT_UART3) */
509  {
510  offset = COMMON_REG_UART_CLK_DIVEN_UART3_Pos;
511  }
512 
513  NT_COMMON_REG->UART_CLK &= ~(0x7F << offset);
514  NT_COMMON_REG->UART_CLK |= (DivVal << (offset+1)) | (DivState << offset);
515 }
516 
525 void RCC_UARTClkCmd(NT_UART_TypeDef* UARTx, FunctionalState State)
526 {
527  uint32_t offset;
528 
529  /* Check the parameters */
530  assert_param(IS_UART_ALL_PERIPH(UARTx));
531  assert_param(IS_FUNCTIONAL_STATE(State));
532 
533  if (UARTx == NT_UART0)
534  {
535  offset = COMMON_REG_UART_CLK_CLKEN_UART0_Pos;
536  }
537  else if (UARTx == NT_UART1)
538  {
539  offset = COMMON_REG_UART_CLK_CLKEN_UART1_Pos;
540  }
541  else if (UARTx == NT_UART2)
542  {
543  offset = COMMON_REG_UART_CLK_CLKEN_UART2_Pos;
544  }
545  else /* (UARTx == NT_UART3) */
546  {
547  offset = COMMON_REG_UART_CLK_CLKEN_UART3_Pos;
548  }
549 
550  if (State == ENABLE)
551  {
552  NT_COMMON_REG->UART_CLK |= (1 << offset);
553  }
554  else if (State == DISABLE)
555  {
556  NT_COMMON_REG->UART_CLK &= ~(1 << offset);
557  }
558 }
559 
568 void RCC_SPIClkSel(NT_SPI_TypeDef* SPIx, RCC_SPIClk_TypeDef RCC_SPIClk)
569 {
570  uint32_t offset;
571 
572  /* Check the parameters */
573  assert_param(IS_SPI_ALL_PERIPH(SPIx));
574  assert_param(IS_RCC_SPI_CLK(RCC_SPIClk));
575 
576  if (SPIx == NT_SPI0)
577  {
578  offset = COMMON_REG_UART_SPI_CLK_SEL_SEL_SPI0_Pos;
579  }
580  else if (SPIx == NT_SPI1)
581  {
582  offset = COMMON_REG_UART_SPI_CLK_SEL_SEL_SPI1_Pos;
583  }
584  else if (SPIx == NT_SPI2)
585  {
586  offset = COMMON_REG_UART_SPI_CLK_SEL_SEL_SPI2_Pos;
587  }
588  else /* (SPIx == NT_SPI3) */
589  {
590  offset = COMMON_REG_UART_SPI_CLK_SEL_SEL_SPI3_Pos;
591  }
592 
593  NT_COMMON_REG->UART_SPI_CLK_SEL &= ~(3<<offset);
594  NT_COMMON_REG->UART_SPI_CLK_SEL |= (RCC_SPIClk<<offset);
595 }
596 
597 
609 void RCC_SPIClkDivConfig(NT_SPI_TypeDef* SPIx, uint32_t DivVal, FunctionalState DivState)
610 {
611  uint32_t offset;
612 
613  /* Check the parameters */
614  assert_param(IS_SPI_ALL_PERIPH(SPIx));
615  assert_param(IS_RCC_CLK_DIV(DivVal));
616  assert_param(IS_FUNCTIONAL_STATE(DivState));
617 
618  if (SPIx == NT_SPI0)
619  {
620  offset = COMMON_REG_SPI_CLK_DIVEN_SPI0_Pos;
621  }
622  else if (SPIx == NT_SPI1)
623  {
624  offset = COMMON_REG_SPI_CLK_DIVEN_SPI1_Pos;
625  }
626  else if (SPIx == NT_SPI2)
627  {
628  offset = COMMON_REG_SPI_CLK_DIVEN_SPI2_Pos;
629  }
630  else /* (SPIx == NT_SPI3) */
631  {
632  offset = COMMON_REG_SPI_CLK_DIVEN_SPI3_Pos;
633  }
634 
635  NT_COMMON_REG->SPI_CLK &= ~(0x7F << offset);
636  NT_COMMON_REG->SPI_CLK |= (DivVal << (offset+1)) | (DivState << offset);
637 }
638 
647 void RCC_SPIClkCmd(NT_SPI_TypeDef* SPIx, FunctionalState State)
648 {
649  uint32_t offset;
650 
651  /* Check the parameters */
652  assert_param(IS_SPI_ALL_PERIPH(SPIx));
653  assert_param(IS_FUNCTIONAL_STATE(State));
654 
655  if (SPIx == NT_SPI0)
656  {
657  offset = COMMON_REG_SPI_CLK_CLKEN_SPI0_Pos;
658  }
659  else if (SPIx == NT_SPI1)
660  {
661  offset = COMMON_REG_SPI_CLK_CLKEN_SPI1_Pos;
662  }
663  else if (SPIx == NT_SPI2)
664  {
665  offset = COMMON_REG_SPI_CLK_CLKEN_SPI2_Pos;
666  }
667  else /* (SPIx == NT_SPI3) */
668  {
669  offset = COMMON_REG_SPI_CLK_CLKEN_SPI3_Pos;
670  }
671 
672  if (State == ENABLE)
673  {
674  NT_COMMON_REG->SPI_CLK |= (1 << offset);
675  }
676  else if (State == DISABLE)
677  {
678  NT_COMMON_REG->SPI_CLK &= ~(1 << offset);
679  }
680 }
681 
694 void RCC_ADCClkDivConfig(RCC_ADCClk_TypeDef RCC_ADCClk, uint32_t DivVal, FunctionalState DivState)
695 {
696  uint32_t offset;
697  volatile uint32_t* ctrl_reg;
698 
699  /* Check the parameters */
700  assert_param(IS_RCC_ADC_CLK(RCC_ADCClk));
701  assert_param(IS_RCC_CLK_DIV(DivVal));
702  assert_param(IS_FUNCTIONAL_STATE(DivState));
703 
704  if (RCC_ADCClk == RCC_ADCClk_0)
705  {
706  offset = COMMON_REG_ADC_CTRL0_DIVEN_ADC0_Pos;
707  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL0);
708  }
709  else if (RCC_ADCClk == RCC_ADCClk_1)
710  {
711  offset = COMMON_REG_ADC_CTRL0_DIVEN_ADC1_Pos;
712  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL0);
713  }
714  else if (RCC_ADCClk == RCC_ADCClk_2)
715  {
716  offset = COMMON_REG_ADC_CTRL0_DIVEN_ADC2_Pos;
717  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL0);
718  }
719  else if (RCC_ADCClk == RCC_ADCClk_3)
720  {
721  offset = COMMON_REG_ADC_CTRL0_DIVEN_ADC3_Pos;
722  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL0);
723  }
724  else if (RCC_ADCClk == RCC_ADCClk_4)
725  {
726  offset = COMMON_REG_ADC_CTRL1_DIVEN_ADC4_Pos;
727  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
728  }
729  else if (RCC_ADCClk == RCC_ADCClk_5)
730  {
731  offset = COMMON_REG_ADC_CTRL1_DIVEN_ADC5_Pos;
732  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
733  }
734  else if (RCC_ADCClk == RCC_ADCClk_6)
735  {
736  offset = COMMON_REG_ADC_CTRL1_DIVEN_ADC6_Pos;
737  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
738  }
739  else if (RCC_ADCClk == RCC_ADCClk_7)
740  {
741  offset = COMMON_REG_ADC_CTRL1_DIVEN_ADC7_Pos;
742  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
743  }
744  else if (RCC_ADCClk == RCC_ADCClk_8)
745  {
746  offset = COMMON_REG_ADC_CTRL2_DIVEN_ADC8_Pos;
747  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
748  }
749  else if (RCC_ADCClk == RCC_ADCClk_9)
750  {
751  offset = COMMON_REG_ADC_CTRL2_DIVEN_ADC9_Pos;
752  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
753  }
754  else if (RCC_ADCClk == RCC_ADCClk_10)
755  {
756  offset = COMMON_REG_ADC_CTRL2_DIVEN_ADC10_Pos;
757  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
758  }
759  else /* (RCC_ADCClk == RCC_ADCClk_11) */
760  {
761  offset = COMMON_REG_ADC_CTRL2_DIVEN_ADC11_Pos;
762  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
763  }
764 
765  *ctrl_reg &= ~(0x7F << offset);
766  *ctrl_reg |= (DivVal << (offset+1)) | (DivState << offset);
767 }
768 
779 {
780  uint32_t offset;
781  volatile uint32_t* ctrl_reg;
782 
783  /* Check the parameters */
784  assert_param(IS_RCC_ADC_CLK(RCC_ADCClk));
785  assert_param(IS_FUNCTIONAL_STATE(State));
786 
787  if (RCC_ADCClk == RCC_ADCClk_0)
788  {
789  offset = COMMON_REG_ADC_CTRL0_CLKEN_ADC0_Pos;
790  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL0);
791  }
792  else if (RCC_ADCClk == RCC_ADCClk_1)
793  {
794  offset = COMMON_REG_ADC_CTRL0_CLKEN_ADC1_Pos;
795  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL0);
796  }
797  else if (RCC_ADCClk == RCC_ADCClk_2)
798  {
799  offset = COMMON_REG_ADC_CTRL0_CLKEN_ADC2_Pos;
800  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL0);
801  }
802  else if (RCC_ADCClk == RCC_ADCClk_3)
803  {
804  offset = COMMON_REG_ADC_CTRL0_CLKEN_ADC3_Pos;
805  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL0);
806  }
807  else if (RCC_ADCClk == RCC_ADCClk_4)
808  {
809  offset = COMMON_REG_ADC_CTRL1_CLKEN_ADC4_Pos;
810  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
811  }
812  else if (RCC_ADCClk == RCC_ADCClk_5)
813  {
814  offset = COMMON_REG_ADC_CTRL1_CLKEN_ADC5_Pos;
815  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
816  }
817  else if (RCC_ADCClk == RCC_ADCClk_6)
818  {
819  offset = COMMON_REG_ADC_CTRL1_CLKEN_ADC6_Pos;
820  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
821  }
822  else if (RCC_ADCClk == RCC_ADCClk_7)
823  {
824  offset = COMMON_REG_ADC_CTRL1_CLKEN_ADC7_Pos;
825  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
826  }
827  else if (RCC_ADCClk == RCC_ADCClk_8)
828  {
829  offset = COMMON_REG_ADC_CTRL2_CLKEN_ADC8_Pos;
830  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
831  }
832  else if (RCC_ADCClk == RCC_ADCClk_9)
833  {
834  offset = COMMON_REG_ADC_CTRL2_CLKEN_ADC9_Pos;
835  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
836  }
837  else if (RCC_ADCClk == RCC_ADCClk_10)
838  {
839  offset = COMMON_REG_ADC_CTRL2_CLKEN_ADC10_Pos;
840  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
841  }
842  else /* (RCC_ADCClk == RCC_ADCClk_11) */
843  {
844  offset = COMMON_REG_ADC_CTRL2_CLKEN_ADC11_Pos;
845  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
846  }
847 
848  if (State == ENABLE)
849  {
850  *ctrl_reg |= (1 << offset);
851  }
852  else if (State == DISABLE)
853  {
854  *ctrl_reg &= ~(1 << offset);
855  }
856 
857 }
858 
869 {
870  volatile uint32_t* ctrl_reg;
871  uint32_t offset = 0;
872 
873  /* Check the parameters */
874  assert_param(IS_RCC_PERIPH_RST(RCC_PeriphRst));
875  assert_param(IS_FUNCTIONAL_STATE(State));
876 
877  if (RCC_PeriphRst <= RCC_PeriphRst_ETH)
878  {
879  ctrl_reg = &(NT_COMMON_REG->PER_RST0);
880  }
881  else
882  {
883  ctrl_reg = &(NT_COMMON_REG->PER_RST1);
884  offset = (uint32_t)RCC_PeriphRst_ETH + 1; //последняя периферия в rst1
885  }
886 
887  if (State == ENABLE)
888  {
889  *ctrl_reg |= (1<<(RCC_PeriphRst-offset));
890  }
891  else if (State == DISABLE)
892  {
893  *ctrl_reg &= ~(1<<(RCC_PeriphRst-offset));
894  }
895 }
896 
913 /******************* (C) COPYRIGHT 2015 NIIET *****END OF FILE****/
RCC_UARTClk_TypeDef
Выбор источника тактирования для UART.
Definition: niietcm4_rcc.h:108
void RCC_SPIClkCmd(NT_SPI_TypeDef *SPIx, FunctionalState State)
Включение тактирования SPI.
Definition: niietcm4_rcc.c:647
RCC_PLLRef_TypeDef
Выбор источника опорного сигнала PLL.
Definition: niietcm4_rcc.h:67
OperationStatus
Описывает коды возврата для функций при выполнении какой-либо операции.
Definition: niietcm4.h:185
RCC_SysClk_TypeDef RCC_SysClkStatus(void)
Текущий источник системного тактового сигнала.
Definition: niietcm4_rcc.c:396
#define IS_RCC_PLL_REF(PLL_REF)
Макрос проверки аргументов типа RCC_PLLRef_TypeDef.
Definition: niietcm4_rcc.h:79
RCC_ADCClk_TypeDef
Выбор модуля ADC для настройки его тактового сигнала.
Definition: niietcm4_rcc.h:184
#define IS_RCC_CLK_DIV(CLK_DIV)
Макрос проверки значения делителя тактового сигнала на попадание в допустимый диапазон.
Definition: niietcm4_rcc.h:413
void RCC_PeriphClkCmd(RCC_PeriphClk_TypeDef RCC_PeriphClk, FunctionalState State)
Включение тактирования выбранного блока периферии.
Definition: niietcm4_rcc.c:344
Файл содержит все прототипы функций для RCC (Reset &amp; Clock Control).
#define IS_RCC_PLL_NO(PLL_NO)
Макрос проверки аргументов типа RCC_PLLNO_TypeDef.
Definition: niietcm4_rcc.h:100
#define RCC_PLL_OD_Reset_Value
Definition: niietcm4_rcc.c:66
void RCC_UARTClkSel(NT_UART_TypeDef *UARTx, RCC_UARTClk_TypeDef RCC_UARTClk)
Настройка источника тактового сигнала для выбранного UART.
Definition: niietcm4_rcc.c:447
void RCC_SysClkDiv2Out(FunctionalState State)
Включение генерации тактового сигнала с частой равной половине системной на выводе H[0]...
Definition: niietcm4_rcc.c:117
GPIO_AltFunc_TypeDef GPIO_AltFunc
#define IS_SPI_ALL_PERIPH(PERIPH)
Макрос проверки аргументов типа NT_SPI_TypeDef.
Definition: niietcm4.h:235
void GPIO_Init(NT_GPIO_TypeDef *GPIOx, GPIO_Init_TypeDef *GPIO_InitStruct)
Инициализирует модуль GPIOx согласно параметрам структуры GPIO_InitStruct.
#define RCC_CLK_PLL_STABLE_TIMEOUT
Definition: niietcm4_rcc.h:53
void GPIO_StructInit(GPIO_Init_TypeDef *GPIO_InitStruct)
Заполнение каждого члена структуры GPIO_InitStruct значениями по умолчанию.
#define IS_RCC_ADC_CLK(ADC_CLK)
Макрос проверки аргументов типа RCC_ADCClk_TypeDef.
Definition: niietcm4_rcc.h:204
#define IS_RCC_USB_CLK(USB_CLK)
Макрос проверки аргументов типа RCC_USBClk_TypeDef.
Definition: niietcm4_rcc.h:160
#define IS_UART_ALL_PERIPH(PERIPH)
Макрос проверки аргументов типа NT_UART_TypeDef.
Definition: niietcm4.h:226
Структура инициализации PLL.
Definition: niietcm4_rcc.h:377
#define IS_RCC_SPI_CLK(SPI_CLK)
Макрос проверки аргументов типа RCC_SPIClk_TypeDef.
Definition: niietcm4_rcc.h:141
#define RCC_PLL_NF_Reset_Value
Definition: niietcm4_rcc.c:68
#define IS_RCC_USB_FREQ(USB_FREQ)
Макрос проверки аргументов типа RCC_USBFreq_TypeDef.
Definition: niietcm4_rcc.h:177
RCC_USBClk_TypeDef
Выбор источника тактирования для USB.
Definition: niietcm4_rcc.h:150
#define IS_RCC_PLLDIV(PLLDIV)
Макрос проверки значения выходного делителя PLL на попадание в допустимый диапазон.
Definition: niietcm4_rcc.h:395
void RCC_ADCClkDivConfig(RCC_ADCClk_TypeDef RCC_ADCClk, uint32_t DivVal, FunctionalState DivState)
Настройка делителя тактового сигнала для выбранного ADC.
Definition: niietcm4_rcc.c:694
RCC_PLLNO_TypeDef
Выходной делитель NO.
Definition: niietcm4_rcc.h:89
void RCC_UARTClkDivConfig(NT_UART_TypeDef *UARTx, uint32_t DivVal, FunctionalState DivState)
Настройка делителя тактового сигнала для выбранного UART.
Definition: niietcm4_rcc.c:487
void RCC_PeriphRstCmd(RCC_PeriphRst_TypeDef RCC_PeriphRst, FunctionalState State)
Вывод из состояния сброса периферийных блоков.
Definition: niietcm4_rcc.c:868
void RCC_SPIClkSel(NT_SPI_TypeDef *SPIx, RCC_SPIClk_TypeDef RCC_SPIClk)
Настройка источника тактового сигнала для выбранного SPI.
Definition: niietcm4_rcc.c:568
#define IS_RCC_SYS_CLK(SYS_CLK)
Макрос проверки аргументов типа RCC_SysClk_TypeDef.
Definition: niietcm4_rcc.h:237
#define IS_RCC_SYS_FREQ(SYS_FREQ)
Макрос проверки значения желаемой частоты при автонастройке в допустимый диапазон.
Definition: niietcm4_rcc.h:419
RCC_SPIClk_TypeDef
Выбор источника тактирования для SPI.
Definition: niietcm4_rcc.h:129
void RCC_UARTClkCmd(NT_UART_TypeDef *UARTx, FunctionalState State)
Включение тактирования UART.
Definition: niietcm4_rcc.c:525
#define IS_RCC_PERIPH_CLK(PERIPH_CLK)
Макрос проверки аргументов типа RCC_PeriphClk_TypeDef.
Definition: niietcm4_rcc.h:274
GPIO_Out_TypeDef GPIO_Out
Структура инициализации GPIO.
void RCC_ADCClkCmd(RCC_ADCClk_TypeDef RCC_ADCClk, FunctionalState State)
Включение тактирования ADC.
Definition: niietcm4_rcc.c:778
void RCC_PLLPowerDownCmd(FunctionalState State)
Управление режимом PowerDown PLL.
Definition: niietcm4_rcc.c:315
RCC_PLLNO_TypeDef RCC_PLLNO
Definition: niietcm4_rcc.h:383
OperationStatus RCC_PLLAutoConfig(RCC_PLLRef_TypeDef RCC_PLLRef, uint32_t SysFreq)
Автоматическая конфигурация PLL для получения желаемой системной частоты.
Definition: niietcm4_rcc.c:153
#define RCC_PLL_DIV_EN_FREQ
Definition: niietcm4_rcc.c:55
void RCC_USBClkConfig(RCC_USBClk_TypeDef RCC_USBClk, RCC_USBFreq_TypeDef RCC_USBFreq, FunctionalState State)
Настройка источника и включение тактового сигнала для USB.
Definition: niietcm4_rcc.c:412
RCC_USBFreq_TypeDef
Выбор фиксированной частоты на входе CLK_USB.
Definition: niietcm4_rcc.h:167
#define IS_RCC_UART_CLK(UART_CLK)
Макрос проверки аргументов типа RCC_UARTClk_TypeDef.
Definition: niietcm4_rcc.h:120
GPIO_Mode_TypeDef GPIO_Mode
RCC_PLLRef_TypeDef RCC_PLLRef
Definition: niietcm4_rcc.h:381
FunctionalState
Описывает логическое состояние периферии. Используется для операций включения/выключения периферийных...
Definition: niietcm4.h:169
#define IS_RCC_PLL_NF(PLL_NF)
Макрос проверки значения делителя ОС PLL на попадание в допустимый диапазон.
Definition: niietcm4_rcc.h:407
void RCC_PLLInit(RCC_PLLInit_TypeDef *RCC_PLLInit_Struct)
Инициализирует PLL согласно параметрам структуры RCC_PLLInit_Struct.
Definition: niietcm4_rcc.c:264
OperationStatus RCC_SysClkSel(RCC_SysClk_TypeDef RCC_SysClk)
Выбор источника для системного тактового сигнала.
Definition: niietcm4_rcc.c:367
#define RCC_PLL_REF_FREQ
Definition: niietcm4_rcc.c:54
#define IS_RCC_PLL_NR(PLL_NR)
Макрос проверки значения опорного делителя PLL на попадание в допустимый диапазон.
Definition: niietcm4_rcc.h:401
RCC_PeriphRst_TypeDef
Управление сбросом периферийных блоков
Definition: niietcm4_rcc.h:295
#define IS_FUNCTIONAL_STATE(STATE)
Макрос проверки аргументов типа FunctionalState.
Definition: niietcm4.h:179
GPIO_Dir_TypeDef GPIO_Dir
#define RCC_CLK_CHANGE_TIMEOUT
Definition: niietcm4_rcc.h:52
RCC_PeriphClk_TypeDef
Управление тактированием периферийных блоков
Definition: niietcm4_rcc.h:250
#define EXT_OSC_VALUE
Определение частоты используемого внешнего тактового генератора.
Definition: niietcm4.h:73
RCC_SysClk_TypeDef
Выбор источника системной частоты.
Definition: niietcm4_rcc.h:221
#define RCC_PLL_NR_Reset_Value
Definition: niietcm4_rcc.c:67
#define GPIO_Pin_0
#define RCC_PLL_CTRL_Reset_Value
Definition: niietcm4_rcc.c:65
void RCC_PLLStructInit(RCC_PLLInit_TypeDef *RCC_PLLInit_Struct)
Заполнение каждого члена структуры RCC_PLLInit_Struct значениями по умолчанию.
Definition: niietcm4_rcc.c:286
#define IS_RCC_PERIPH_RST(PERIPH_RST)
Макрос проверки аргументов типа RCC_PeriphRst_TypeDef.
Definition: niietcm4_rcc.h:337
void RCC_PLLDeInit(void)
Устанавливает все регистры PLL значениями по умолчанию.
Definition: niietcm4_rcc.c:300
void RCC_SPIClkDivConfig(NT_SPI_TypeDef *SPIx, uint32_t DivVal, FunctionalState DivState)
Настройка делителя тактового сигнала для выбранного SPI.
Definition: niietcm4_rcc.c:609