NIIETCM4 PD  v0.8.0
Драйвер периферии для микроконтроллеров на базе ядра ARM Cortex-M4
niietcm4_rcc.c
См. документацию.
1 
30 /* Includes ------------------------------------------------------------------*/
31 #include "niietcm4_rcc.h"
32 
54 #define RCC_PLL_CTRL_Reset_Value ((uint32_t)0x00000000)
55 #define RCC_PLL_OD_Reset_Value ((uint32_t)0x00000000)
56 #define RCC_PLL_NR_Reset_Value ((uint32_t)0x00000000)
57 #define RCC_PLL_NF_Reset_Value ((uint32_t)0x00000000)
77 uint32_t RCC_WaitClkChange(RCC_SysClk_TypeDef RCC_SysClk)
78 {
79  uint32_t timeout = RCC_CLK_CHANGE_TIMEOUT;
80 
81  while(timeout)
82  {
83  if ((RCC_SysClk_TypeDef)(NT_COMMON_REG->SYS_CLK_bit.CURR_SRC) == RCC_SysClk)
84  {
85  break;
86  }
87  else
88  {
89  timeout--;
90  }
91  }
92 
93  return timeout;
94 }
95 
107 {
108  /* Check the parameters */
109  assert_param(IS_FUNCTIONAL_STATE(State));
110 
111  GPIO_Init_TypeDef GPIO_Init_Struct;
112 
113  GPIO_StructInit(&GPIO_Init_Struct);
114 
115  GPIO_Init_Struct.GPIO_Pin = GPIO_Pin_0;
116  if (State == ENABLE)
117  {
118  GPIO_Init_Struct.GPIO_Dir = GPIO_Dir_Out;
119  GPIO_Init_Struct.GPIO_AltFunc = GPIO_AltFunc_2;
120  GPIO_Init_Struct.GPIO_Mode = GPIO_Mode_AltFunc;
121  GPIO_Init_Struct.GPIO_Out = GPIO_Out_En;
122  }
123 
124  GPIO_Init(NT_GPIOH, &GPIO_Init_Struct);
125 }
126 
143 {
144  uint32_t f_in = 0;
145  uint32_t nf, nr;
147  uint32_t pll_div = 0;
148  uint32_t f_ref = 1000000; /* 1 MHz */
149  OperationStatus status;
150  RCC_PLLInit_TypeDef RCC_PLLInit_Struct;
151  FunctionalState pll_div_cmd = DISABLE;
152  volatile uint32_t pll_stable_wait = RCC_CLK_PLL_STABLE_TIMEOUT;
153 
154  /* Check the parameters */
155  assert_param(IS_RCC_PLL_REF(RCC_PLLRef));
156  assert_param(IS_RCC_SYS_FREQ(SysFreq));
157 
158  if (RCC_PLLRef == RCC_PLLRef_XI_OSC)
159  {
160  f_in = EXT_OSC_VALUE;
161  }
162  else if (RCC_PLLRef == RCC_PLLRef_USB_CLK)
163  {
164  if (NT_COMMON_REG->USB_CTRL_bit.FSEL)
165  {
166  f_in = (uint32_t)(24000000);
167  }
168  else
169  {
170  f_in = (uint32_t)(12000000);
171  }
172  }
173  else if (RCC_PLLRef == RCC_PLLRef_USB_60MHz)
174  {
175  f_in = (uint32_t)(60000000);
176  }
177  else if (RCC_PLLRef == RCC_PLLRef_ETH_25MHz)
178  {
179  f_in = (uint32_t)(25000000);
180  }
181 
182  if (SysFreq >= 100000000)
183  {
184  no = RCC_PLLNO_Div2;
185  }
186  else if ((SysFreq >= 50000000))
187  {
188  no = RCC_PLLNO_Div4;
189  }
190  else
191  {
192  no = RCC_PLLNO_Div4;
193  pll_div = (50000000/SysFreq + 1)/2 - 1;
194  pll_div_cmd = ENABLE;
195  }
196 
197  nr = f_in/(2*f_ref);
198  if (pll_div_cmd == DISABLE)
199  {
200  nf = ((SysFreq/1000000) * ((uint32_t)no + 1) * nr )/(f_in/1000000);
201  }
202  else /* (pll_div_cmd == ENABLE) */
203  {
204  nf = ((SysFreq/1000000) * ((uint32_t)no + 1) * nr * 2*(pll_div+1) )/(f_in/1000000);
205  }
206 
207 
208  RCC_PLLInit_Struct.RCC_PLLRef = RCC_PLLRef;
209  RCC_PLLInit_Struct.RCC_PLLDiv = pll_div;
210  RCC_PLLInit_Struct.RCC_PLLNO = no;
211  RCC_PLLInit_Struct.RCC_PLLNF = nf;
212  RCC_PLLInit_Struct.RCC_PLLNR = nr;
213 
214  RCC_PLLInit(&RCC_PLLInit_Struct);
215 
216  while(pll_stable_wait)
217  {
218  pll_stable_wait--;
219  }
220 
221  if (pll_div_cmd == DISABLE)
222  {
223  status = RCC_SysClkSel(RCC_SysClk_PLL);
224  }
225  else /* (pll_div_cmd == ENABLE) */
226  {
228  }
229 
230  return status;
231 }
232 
262 void RCC_PLLInit(RCC_PLLInit_TypeDef* RCC_PLLInit_Struct)
263 {
264  assert_param(IS_RCC_PLLDIV(RCC_PLLInit_Struct->RCC_PLLDiv));
265  assert_param(IS_RCC_PLL_NF(RCC_PLLInit_Struct->RCC_PLLNF));
266  assert_param(IS_RCC_PLL_NO(RCC_PLLInit_Struct->RCC_PLLNO));
267  assert_param(IS_RCC_PLL_NR(RCC_PLLInit_Struct->RCC_PLLNR));
268  assert_param(IS_RCC_PLL_REF(RCC_PLLInit_Struct->RCC_PLLRef));
269 
270  NT_COMMON_REG->PLL_CTRL_bit.REFSEL = ((uint32_t)(RCC_PLLInit_Struct->RCC_PLLRef));
271  NT_COMMON_REG->PLL_CTRL_bit.PLL_DIV = RCC_PLLInit_Struct->RCC_PLLDiv;
272  NT_COMMON_REG->PLL_OD = ((uint32_t)(RCC_PLLInit_Struct->RCC_PLLNO));
273  NT_COMMON_REG->PLL_NF = RCC_PLLInit_Struct->RCC_PLLNF - 2;
274  NT_COMMON_REG->PLL_NR = RCC_PLLInit_Struct->RCC_PLLNR - 2;
275 }
276 
284 void RCC_PLLStructInit(RCC_PLLInit_TypeDef* RCC_PLLInit_Struct)
285 {
286  RCC_PLLInit_Struct->RCC_PLLRef = RCC_PLLRef_XI_OSC;
287  RCC_PLLInit_Struct->RCC_PLLDiv = 0;
288  RCC_PLLInit_Struct->RCC_PLLNO = RCC_PLLNO_Disable;
289  RCC_PLLInit_Struct->RCC_PLLNF = 2;
290  RCC_PLLInit_Struct->RCC_PLLNR = 2;
291 }
292 
299 {
300  NT_COMMON_REG->PLL_CTRL = RCC_PLL_CTRL_Reset_Value;
301  NT_COMMON_REG->PLL_OD = RCC_PLL_OD_Reset_Value;
302  NT_COMMON_REG->PLL_NF = RCC_PLL_NF_Reset_Value;
303  NT_COMMON_REG->PLL_NR = RCC_PLL_NR_Reset_Value;
304 }
305 
314 {
315  /* Check the parameters */
316  assert_param(IS_FUNCTIONAL_STATE(State));
317 
318  if (State == DISABLE)
319  {
320  NT_COMMON_REG->PLL_CTRL_bit.PD = 0;
321  }
322  else if (State == ENABLE)
323  {
324  NT_COMMON_REG->PLL_CTRL_bit.PD = 1;
325  }
326 }
327 
343 {
344  /* Check the parameters */
345  assert_param(IS_RCC_PERIPH_CLK(RCC_PeriphClk));
346  assert_param(IS_FUNCTIONAL_STATE(State));
347 
348  if (State == ENABLE)
349  {
350  NT_COMMON_REG->APB_CLK |= RCC_PeriphClk;
351  }
352  else if (State == DISABLE)
353  {
354  NT_COMMON_REG->APB_CLK &= ~RCC_PeriphClk;
355  }
356 }
357 
366 {
367  uint32_t timeout;
368  OperationStatus status;
369 
370  /* Check the parameters */
371  assert_param(IS_RCC_SYS_CLK(RCC_SysClk));
372 
373  NT_COMMON_REG->SYS_CLK = ((uint32_t)RCC_SysClk);
374 
375  timeout = RCC_WaitClkChange(RCC_SysClk);
376 
377  if (timeout)
378  {
379  status = OK;
380  }
381  else
382  {
383  status = ERROR;
384  }
385 
386  return status;
387 }
388 
395 {
396  return((RCC_SysClk_TypeDef)((NT_COMMON_REG->SYS_CLK)>>SYS_CLK_CURR_SRC_Pos));
397 }
398 
409 {
410  /* Check the parameters */
411  assert_param(IS_RCC_USB_CLK(RCC_USBClk));
412  assert_param(IS_RCC_USB_FREQ(RCC_USBFreq));
413 
414  NT_COMMON_REG->USB_CTRL &= ~((1<<USB_CTRL_FSEL_Pos) | (1<<USB_CTRL_CLKSEL_Pos));
415  NT_COMMON_REG->USB_CTRL |= (RCC_USBFreq<<USB_CTRL_FSEL_Pos) | (RCC_USBClk<<USB_CTRL_CLKSEL_Pos);
416 }
417 
426 {
427  /* Check the parameters */
428  assert_param(IS_FUNCTIONAL_STATE(State));
429 
430  if (State == ENABLE)
431  {
432  NT_COMMON_REG->USB_CTRL_bit.CLKEN = 1;
433  }
434  else if (State == DISABLE)
435  {
436  NT_COMMON_REG->USB_CTRL_bit.CLKEN = 0;
437  }
438 }
439 
448 void RCC_UARTClkSel(NT_UART_TypeDef* UARTx, RCC_UARTClk_TypeDef RCC_UARTClk)
449 {
450  uint32_t offset;
451 
452  /* Check the parameters */
453  assert_param(IS_UART_ALL_PERIPH(UARTx));
454  assert_param(IS_RCC_UART_CLK(RCC_UARTClk));
455 
456  if (UARTx == NT_UART0)
457  {
458  offset = UART_SPI_CLK_SEL_SEL_UART0_Pos;
459  }
460  else if (UARTx == NT_UART1)
461  {
462  offset = UART_SPI_CLK_SEL_SEL_UART1_Pos;
463  }
464  else if (UARTx == NT_UART2)
465  {
466  offset = UART_SPI_CLK_SEL_SEL_UART2_Pos;
467  }
468  else /* (UARTx == NT_UART3) */
469  {
470  offset = UART_SPI_CLK_SEL_SEL_UART3_Pos;
471  }
472 
473  NT_COMMON_REG->UART_SPI_CLK_SEL &= ~(3<<offset);
474  NT_COMMON_REG->UART_SPI_CLK_SEL |= (RCC_UARTClk<<offset);
475 }
476 
488 void RCC_UARTClkDivConfig(NT_UART_TypeDef* UARTx, uint32_t DivVal, FunctionalState DivState)
489 {
490  uint32_t offset;
491 
492  /* Check the parameters */
493  assert_param(IS_UART_ALL_PERIPH(UARTx));
494  assert_param(IS_RCC_CLK_DIV(DivVal));
495  assert_param(IS_FUNCTIONAL_STATE(DivState));
496 
497  if (UARTx == NT_UART0)
498  {
499  offset = UART_CLK_DIVEN_UART0_Pos;
500  }
501  else if (UARTx == NT_UART1)
502  {
503  offset = UART_CLK_DIVEN_UART1_Pos;
504  }
505  else if (UARTx == NT_UART2)
506  {
507  offset = UART_CLK_DIVEN_UART2_Pos;
508  }
509  else /* (UARTx == NT_UART3) */
510  {
511  offset = UART_CLK_DIVEN_UART3_Pos;
512  }
513 
514  NT_COMMON_REG->UART_CLK &= ~(0x7F << offset);
515  NT_COMMON_REG->UART_CLK |= (DivVal << (offset+1)) | (DivState << offset);
516 }
517 
526 void RCC_UARTClkCmd(NT_UART_TypeDef* UARTx, FunctionalState State)
527 {
528  uint32_t offset;
529 
530  /* Check the parameters */
531  assert_param(IS_UART_ALL_PERIPH(UARTx));
532  assert_param(IS_FUNCTIONAL_STATE(State));
533 
534  if (UARTx == NT_UART0)
535  {
536  offset = UART_CLK_CLKEN_UART0_Pos;
537  }
538  else if (UARTx == NT_UART1)
539  {
540  offset = UART_CLK_CLKEN_UART1_Pos;
541  }
542  else if (UARTx == NT_UART2)
543  {
544  offset = UART_CLK_CLKEN_UART2_Pos;
545  }
546  else /* (UARTx == NT_UART3) */
547  {
548  offset = UART_CLK_CLKEN_UART3_Pos;
549  }
550 
551  if (State == ENABLE)
552  {
553  NT_COMMON_REG->UART_CLK |= (1 << offset);
554  }
555  else if (State == DISABLE)
556  {
557  NT_COMMON_REG->UART_CLK &= ~(1 << offset);
558  }
559 }
560 
569 void RCC_SPIClkSel(NT_SPI_TypeDef* SPIx, RCC_SPIClk_TypeDef RCC_SPIClk)
570 {
571  uint32_t offset;
572 
573  /* Check the parameters */
574  assert_param(IS_SPI_ALL_PERIPH(SPIx));
575  assert_param(IS_RCC_SPI_CLK(RCC_SPIClk));
576 
577  if (SPIx == NT_SPI0)
578  {
579  offset = UART_SPI_CLK_SEL_SEL_SPI0_Pos;
580  }
581  else if (SPIx == NT_SPI1)
582  {
583  offset = UART_SPI_CLK_SEL_SEL_SPI1_Pos;
584  }
585  else if (SPIx == NT_SPI2)
586  {
587  offset = UART_SPI_CLK_SEL_SEL_SPI2_Pos;
588  }
589  else /* (SPIx == NT_SPI3) */
590  {
591  offset = UART_SPI_CLK_SEL_SEL_SPI3_Pos;
592  }
593 
594  NT_COMMON_REG->UART_SPI_CLK_SEL &= ~(3<<offset);
595  NT_COMMON_REG->UART_SPI_CLK_SEL |= (RCC_SPIClk<<offset);
596 }
597 
598 
610 void RCC_SPIClkDivConfig(NT_SPI_TypeDef* SPIx, uint32_t DivVal, FunctionalState DivState)
611 {
612  uint32_t offset;
613 
614  /* Check the parameters */
615  assert_param(IS_SPI_ALL_PERIPH(SPIx));
616  assert_param(IS_RCC_CLK_DIV(DivVal));
617  assert_param(IS_FUNCTIONAL_STATE(DivState));
618 
619  if (SPIx == NT_SPI0)
620  {
621  offset = SPI_CLK_DIVEN_SPI0_Pos;
622  }
623  else if (SPIx == NT_SPI1)
624  {
625  offset = SPI_CLK_DIVEN_SPI1_Pos;
626  }
627  else if (SPIx == NT_SPI2)
628  {
629  offset = SPI_CLK_DIVEN_SPI2_Pos;
630  }
631  else /* (SPIx == NT_SPI3) */
632  {
633  offset = SPI_CLK_DIVEN_SPI3_Pos;
634  }
635 
636  NT_COMMON_REG->SPI_CLK &= ~(0x7F << offset);
637  NT_COMMON_REG->SPI_CLK |= (DivVal << (offset+1)) | (DivState << offset);
638 }
639 
648 void RCC_SPIClkCmd(NT_SPI_TypeDef* SPIx, FunctionalState State)
649 {
650  uint32_t offset;
651 
652  /* Check the parameters */
653  assert_param(IS_SPI_ALL_PERIPH(SPIx));
654  assert_param(IS_FUNCTIONAL_STATE(State));
655 
656  if (SPIx == NT_SPI0)
657  {
658  offset = SPI_CLK_CLKEN_SPI0_Pos;
659  }
660  else if (SPIx == NT_SPI1)
661  {
662  offset = SPI_CLK_CLKEN_SPI1_Pos;
663  }
664  else if (SPIx == NT_SPI2)
665  {
666  offset = SPI_CLK_CLKEN_SPI2_Pos;
667  }
668  else /* (SPIx == NT_SPI3) */
669  {
670  offset = SPI_CLK_CLKEN_SPI3_Pos;
671  }
672 
673  if (State == ENABLE)
674  {
675  NT_COMMON_REG->SPI_CLK |= (1 << offset);
676  }
677  else if (State == DISABLE)
678  {
679  NT_COMMON_REG->SPI_CLK &= ~(1 << offset);
680  }
681 }
682 
695 void RCC_ADCClkDivConfig(RCC_ADCClk_TypeDef RCC_ADCClk, uint32_t DivVal, FunctionalState DivState)
696 {
697  uint32_t offset;
698  volatile uint32_t* ctrl_reg;
699 
700  /* Check the parameters */
701  assert_param(IS_RCC_ADC_CLK(RCC_ADCClk));
702  assert_param(IS_RCC_CLK_DIV(DivVal));
703  assert_param(IS_FUNCTIONAL_STATE(DivState));
704 
705  if (RCC_ADCClk == RCC_ADCClk_0)
706  {
707  offset = ADC_CTRL1_DIVEN_ADC0_Pos;
708  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
709  }
710  else if (RCC_ADCClk == RCC_ADCClk_1)
711  {
712  offset = ADC_CTRL1_DIVEN_ADC1_Pos;
713  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
714  }
715  else if (RCC_ADCClk == RCC_ADCClk_2)
716  {
717  offset = ADC_CTRL1_DIVEN_ADC2_Pos;
718  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
719  }
720  else if (RCC_ADCClk == RCC_ADCClk_3)
721  {
722  offset = ADC_CTRL1_DIVEN_ADC3_Pos;
723  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
724  }
725  else if (RCC_ADCClk == RCC_ADCClk_4)
726  {
727  offset = ADC_CTRL2_DIVEN_ADC4_Pos;
728  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
729  }
730  else if (RCC_ADCClk == RCC_ADCClk_5)
731  {
732  offset = ADC_CTRL2_DIVEN_ADC5_Pos;
733  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
734  }
735  else if (RCC_ADCClk == RCC_ADCClk_6)
736  {
737  offset = ADC_CTRL2_DIVEN_ADC6_Pos;
738  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
739  }
740  else if (RCC_ADCClk == RCC_ADCClk_7)
741  {
742  offset = ADC_CTRL2_DIVEN_ADC7_Pos;
743  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
744  }
745  else if (RCC_ADCClk == RCC_ADCClk_8)
746  {
747  offset = ADC_CTRL3_DIVEN_ADC8_Pos;
748  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
749  }
750  else if (RCC_ADCClk == RCC_ADCClk_9)
751  {
752  offset = ADC_CTRL3_DIVEN_ADC9_Pos;
753  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
754  }
755  else if (RCC_ADCClk == RCC_ADCClk_10)
756  {
757  offset = ADC_CTRL3_DIVEN_ADC10_Pos;
758  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
759  }
760  else /* (RCC_ADCClk == RCC_ADCClk_11) */
761  {
762  offset = ADC_CTRL3_DIVEN_ADC11_Pos;
763  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
764  }
765 
766  *ctrl_reg &= ~(0x7F << offset);
767  *ctrl_reg |= (DivVal << (offset+1)) | (DivState << offset);
768 }
769 
780 {
781  uint32_t offset;
782  volatile uint32_t* ctrl_reg;
783 
784  /* Check the parameters */
785  assert_param(IS_RCC_ADC_CLK(RCC_ADCClk));
786  assert_param(IS_FUNCTIONAL_STATE(State));
787 
788  if (RCC_ADCClk == RCC_ADCClk_0)
789  {
790  offset = ADC_CTRL1_CLKEN_ADC0_Pos;
791  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
792  }
793  else if (RCC_ADCClk == RCC_ADCClk_1)
794  {
795  offset = ADC_CTRL1_CLKEN_ADC1_Pos;
796  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
797  }
798  else if (RCC_ADCClk == RCC_ADCClk_2)
799  {
800  offset = ADC_CTRL1_CLKEN_ADC2_Pos;
801  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
802  }
803  else if (RCC_ADCClk == RCC_ADCClk_3)
804  {
805  offset = ADC_CTRL1_CLKEN_ADC3_Pos;
806  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
807  }
808  else if (RCC_ADCClk == RCC_ADCClk_4)
809  {
810  offset = ADC_CTRL2_CLKEN_ADC4_Pos;
811  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
812  }
813  else if (RCC_ADCClk == RCC_ADCClk_5)
814  {
815  offset = ADC_CTRL2_CLKEN_ADC5_Pos;
816  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
817  }
818  else if (RCC_ADCClk == RCC_ADCClk_6)
819  {
820  offset = ADC_CTRL2_CLKEN_ADC6_Pos;
821  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
822  }
823  else if (RCC_ADCClk == RCC_ADCClk_7)
824  {
825  offset = ADC_CTRL2_CLKEN_ADC7_Pos;
826  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
827  }
828  else if (RCC_ADCClk == RCC_ADCClk_8)
829  {
830  offset = ADC_CTRL3_CLKEN_ADC8_Pos;
831  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
832  }
833  else if (RCC_ADCClk == RCC_ADCClk_9)
834  {
835  offset = ADC_CTRL3_CLKEN_ADC9_Pos;
836  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
837  }
838  else if (RCC_ADCClk == RCC_ADCClk_10)
839  {
840  offset = ADC_CTRL3_CLKEN_ADC10_Pos;
841  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
842  }
843  else /* (RCC_ADCClk == RCC_ADCClk_11) */
844  {
845  offset = ADC_CTRL3_CLKEN_ADC11_Pos;
846  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
847  }
848 
849  if (State == ENABLE)
850  {
851  *ctrl_reg |= (1 << offset);
852  }
853  else if (State == DISABLE)
854  {
855  *ctrl_reg &= ~(1 << offset);
856  }
857 
858 }
859 
870 {
871  volatile uint32_t* ctrl_reg;
872  uint32_t offset = 0;
873 
874  /* Check the parameters */
875  assert_param(IS_RCC_PERIPH_RST(RCC_PeriphRst));
876  assert_param(IS_FUNCTIONAL_STATE(State));
877 
878  if (RCC_PeriphRst <= RCC_PeriphRst_ETH)
879  {
880  ctrl_reg = &(NT_COMMON_REG->PER_RST1);
881  }
882  else
883  {
884  ctrl_reg = &(NT_COMMON_REG->PER_RST2);
885  offset = (uint32_t)RCC_PeriphRst_ETH + 1; //последняя периферия в rst1
886  }
887 
888  if (State == ENABLE)
889  {
890  *ctrl_reg |= (1<<(RCC_PeriphRst-offset));
891  }
892  else if (State == DISABLE)
893  {
894  *ctrl_reg &= ~(1<<(RCC_PeriphRst-offset));
895  }
896 }
897 
914 /******************* (C) COPYRIGHT 2015 NIIET *****END OF FILE****/
RCC_UARTClk_TypeDef
Выбор источника тактирования для UART.
Definition: niietcm4_rcc.h:108
void RCC_PLLPowerDownCmd(FunctionalState State)
Управление режимом PowerDown PLL.
Definition: niietcm4_rcc.c:313
OperationStatus RCC_SysClkSel(RCC_SysClk_TypeDef RCC_SysClk)
Выбор источника для системного тактового сигнала.
Definition: niietcm4_rcc.c:365
void RCC_SPIClkCmd(NT_SPI_TypeDef *SPIx, FunctionalState State)
Включение тактирования SPI.
Definition: niietcm4_rcc.c:648
RCC_PLLRef_TypeDef
Выбор источника опорного сигнала PLL.
Definition: niietcm4_rcc.h:67
void RCC_ADCClkDivConfig(RCC_ADCClk_TypeDef RCC_ADCClk, uint32_t DivVal, FunctionalState DivState)
Настройка делителя тактового сигнала для выбранного ADC.
Definition: niietcm4_rcc.c:695
#define IS_RCC_PLL_REF(PLL_REF)
Макрос проверки аргументов типа RCC_PLLRef_TypeDef.
Definition: niietcm4_rcc.h:79
#define IS_RCC_PLL_NR(PLL_NR)
Макрос проверки значения опорного делителя PLL на попадание в допустимый диапазон.
Definition: niietcm4_rcc.h:400
RCC_ADCClk_TypeDef
Выбор модуля ADC для настройки его тактового сигнала.
Definition: niietcm4_rcc.h:184
#define IS_RCC_SYS_FREQ(SYS_FREQ)
Макрос проверки значения желаемой частоты при автонастройке в допустимый диапазон.
Definition: niietcm4_rcc.h:418
Файл содержит все прототипы функций для RCC (Reset & 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:55
#define IS_RCC_PLL_NF(PLL_NF)
Макрос проверки значения делителя ОС PLL на попадание в допустимый диапазон.
Definition: niietcm4_rcc.h:406
FunctionalState
Описывает логическое состояние периферии. Используется для операций включения/выключения периферийных...
Definition: niietcm4.h:157
GPIO_AltFunc_TypeDef GPIO_AltFunc
#define IS_SPI_ALL_PERIPH(PERIPH)
Макрос проверки аргументов типа NT_SPI_TypeDef.
Definition: niietcm4.h:223
#define IS_RCC_PLLDIV(PLLDIV)
Макрос проверки значения выходного делителя PLL на попадание в допустимый диапазон.
Definition: niietcm4_rcc.h:394
void GPIO_Init(NT_GPIO_TypeDef *GPIOx, GPIO_Init_TypeDef *GPIO_InitStruct)
Инициализирует модуль GPIOx согласно параметрам структуры GPIO_InitStruct.
void RCC_UARTClkSel(NT_UART_TypeDef *UARTx, RCC_UARTClk_TypeDef RCC_UARTClk)
Настройка источника тактового сигнала для выбранного UART.
Definition: niietcm4_rcc.c:448
#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
void RCC_PeriphClkCmd(RCC_PeriphClk_TypeDef RCC_PeriphClk, FunctionalState State)
Включение тактирования выбранного блока периферии.
Definition: niietcm4_rcc.c:342
#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:214
Структура инициализации PLL.
Definition: niietcm4_rcc.h:376
#define IS_RCC_SPI_CLK(SPI_CLK)
Макрос проверки аргументов типа RCC_SPIClk_TypeDef.
Definition: niietcm4_rcc.h:141
void RCC_ADCClkCmd(RCC_ADCClk_TypeDef RCC_ADCClk, FunctionalState State)
Включение тактирования ADC.
Definition: niietcm4_rcc.c:779
#define RCC_PLL_NF_Reset_Value
Definition: niietcm4_rcc.c:57
#define IS_RCC_USB_FREQ(USB_FREQ)
Макрос проверки аргументов типа RCC_USBFreq_TypeDef.
Definition: niietcm4_rcc.h:177
RCC_USBClk_TypeDef
Выбор источника тактирования для USB.
Definition: niietcm4_rcc.h:150
void RCC_SPIClkSel(NT_SPI_TypeDef *SPIx, RCC_SPIClk_TypeDef RCC_SPIClk)
Настройка источника тактового сигнала для выбранного SPI.
Definition: niietcm4_rcc.c:569
RCC_PLLNO_TypeDef
Выходной делитель NO.
Definition: niietcm4_rcc.h:89
void RCC_PLLDeInit()
Устанавливает все регистры PLL значениями по умолчанию.
Definition: niietcm4_rcc.c:298
#define IS_RCC_SYS_CLK(SYS_CLK)
Макрос проверки аргументов типа RCC_SysClk_TypeDef.
Definition: niietcm4_rcc.h:237
RCC_SPIClk_TypeDef
Выбор источника тактирования для SPI.
Definition: niietcm4_rcc.h:129
void RCC_UARTClkCmd(NT_UART_TypeDef *UARTx, FunctionalState State)
Включение тактирования UART.
Definition: niietcm4_rcc.c:526
void RCC_SysClkDiv2Out(FunctionalState State)
Включение генерации тактового сигнала с частой равной половине системной на выводе H[0]...
Definition: niietcm4_rcc.c:106
uint32_t RCC_WaitClkChange(RCC_SysClk_TypeDef RCC_SysClk)
Процедура ожидания смены источника тактового сигнала
Definition: niietcm4_rcc.c:77
#define IS_RCC_PERIPH_CLK(PERIPH_CLK)
Макрос проверки аргументов типа RCC_PeriphClk_TypeDef.
Definition: niietcm4_rcc.h:274
void RCC_SPIClkDivConfig(NT_SPI_TypeDef *SPIx, uint32_t DivVal, FunctionalState DivState)
Настройка делителя тактового сигнала для выбранного SPI.
Definition: niietcm4_rcc.c:610
GPIO_Out_TypeDef GPIO_Out
#define IS_RCC_PERIPH_RST(PERIPH_RST)
Макрос проверки аргументов типа RCC_PeriphRst_TypeDef.
Definition: niietcm4_rcc.h:336
Структура инициализации GPIO.
void RCC_UARTClkDivConfig(NT_UART_TypeDef *UARTx, uint32_t DivVal, FunctionalState DivState)
Настройка делителя тактового сигнала для выбранного UART.
Definition: niietcm4_rcc.c:488
RCC_PLLNO_TypeDef RCC_PLLNO
Definition: niietcm4_rcc.h:382
#define IS_RCC_CLK_DIV(CLK_DIV)
Макрос проверки значения делителя тактового сигнала на попадание в допустимый диапазон.
Definition: niietcm4_rcc.h:412
OperationStatus
Описывает коды возврата для функций при выполнении какой-либо операции.
Definition: niietcm4.h:173
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:380
RCC_SysClk_TypeDef RCC_SysClkStatus()
Текущий источник системного тактового сигнала.
Definition: niietcm4_rcc.c:394
#define IS_FUNCTIONAL_STATE(STATE)
Макрос проверки аргументов типа FunctionalState.
Definition: niietcm4.h:167
RCC_PeriphRst_TypeDef
Управление сбросом периферийных блоков
Definition: niietcm4_rcc.h:294
void RCC_USBClkConfig(RCC_USBClk_TypeDef RCC_USBClk, RCC_USBFreq_TypeDef RCC_USBFreq)
Настройка источника тактового сигнала для USB.
Definition: niietcm4_rcc.c:408
GPIO_Dir_TypeDef GPIO_Dir
OperationStatus RCC_PLLAutoConfig(RCC_PLLRef_TypeDef RCC_PLLRef, uint32_t SysFreq)
Автоматическая конфигурация PLL для получения желаемой системной частоты.
Definition: niietcm4_rcc.c:142
void RCC_PLLInit(RCC_PLLInit_TypeDef *RCC_PLLInit_Struct)
Инициализирует PLL согласно параметрам структуры RCC_PLLInit_Struct.
Definition: niietcm4_rcc.c:262
#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
void RCC_PLLStructInit(RCC_PLLInit_TypeDef *RCC_PLLInit_Struct)
Заполнение каждого члена структуры RCC_PLLInit_Struct значениями по умолчанию.
Definition: niietcm4_rcc.c:284
RCC_SysClk_TypeDef
Выбор источника системной частоты.
Definition: niietcm4_rcc.h:221
#define RCC_PLL_NR_Reset_Value
Definition: niietcm4_rcc.c:56
#define GPIO_Pin_0
#define RCC_PLL_CTRL_Reset_Value
Definition: niietcm4_rcc.c:54
void RCC_PeriphRstCmd(RCC_PeriphRst_TypeDef RCC_PeriphRst, FunctionalState State)
Вывод из состояния сброса периферийных блоков.
Definition: niietcm4_rcc.c:869
void RCC_USBClkCmd(FunctionalState State)
Включение тактирования USB.
Definition: niietcm4_rcc.c:425