NIIETCM4 PD  v0.7.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 
153  /* Check the parameters */
154  assert_param(IS_RCC_PLL_REF(RCC_PLLRef));
155  assert_param(IS_RCC_SYS_FREQ(SysFreq));
156 
157  if (RCC_PLLRef == RCC_PLLRef_XI_OSC)
158  {
159  f_in = EXT_OSC_VALUE;
160  }
161  else if (RCC_PLLRef == RCC_PLLRef_USB_CLK)
162  {
163  if (NT_COMMON_REG->USB_CTRL_bit.FSEL)
164  {
165  f_in = (uint32_t)(24000000);
166  }
167  else
168  {
169  f_in = (uint32_t)(12000000);
170  }
171  }
172  else if (RCC_PLLRef == RCC_PLLRef_USB_60MHz)
173  {
174  f_in = (uint32_t)(60000000);
175  }
176  else if (RCC_PLLRef == RCC_PLLRef_ETH_25MHz)
177  {
178  f_in = (uint32_t)(25000000);
179  }
180 
181  if (SysFreq >= 100000000)
182  {
183  no = RCC_PLLNO_Div2;
184  }
185  else if ((SysFreq >= 50000000))
186  {
187  no = RCC_PLLNO_Div4;
188  }
189  else
190  {
191  no = RCC_PLLNO_Div4;
192  pll_div = (50000000/SysFreq + 1)/2 - 1;
193  pll_div_cmd = ENABLE;
194  }
195 
196  nr = f_in/(2*f_ref);
197  if (pll_div_cmd == DISABLE)
198  {
199  nf = ((SysFreq/1000000) * ((uint32_t)no + 1) * nr )/(f_in/1000000);
200  }
201  else /* (pll_div_cmd == ENABLE) */
202  {
203  nf = ((SysFreq/1000000) * ((uint32_t)no + 1) * nr * 2*(pll_div+1) )/(f_in/1000000);
204  }
205 
206 
207  RCC_PLLInit_Struct.RCC_PLLRef = RCC_PLLRef;
208  RCC_PLLInit_Struct.RCC_PLLDiv = pll_div;
209  RCC_PLLInit_Struct.RCC_PLLNO = no;
210  RCC_PLLInit_Struct.RCC_PLLNF = nf;
211  RCC_PLLInit_Struct.RCC_PLLNR = nr;
212 
213  RCC_PLLInit(&RCC_PLLInit_Struct);
214 
215  if (pll_div_cmd == DISABLE)
216  {
217  status = RCC_SysClkSel(RCC_SysClk_PLL);
218  }
219  else /* (pll_div_cmd == ENABLE) */
220  {
222  }
223 
224  return status;
225 }
226 
256 void RCC_PLLInit(RCC_PLLInit_TypeDef* RCC_PLLInit_Struct)
257 {
258  assert_param(IS_RCC_PLLDIV(RCC_PLLInit_Struct->RCC_PLLDiv));
259  assert_param(IS_RCC_PLL_NF(RCC_PLLInit_Struct->RCC_PLLNF));
260  assert_param(IS_RCC_PLL_NO(RCC_PLLInit_Struct->RCC_PLLNO));
261  assert_param(IS_RCC_PLL_NR(RCC_PLLInit_Struct->RCC_PLLNR));
262  assert_param(IS_RCC_PLL_REF(RCC_PLLInit_Struct->RCC_PLLRef));
263 
264  NT_COMMON_REG->PLL_CTRL_bit.REFSEL = ((uint32_t)(RCC_PLLInit_Struct->RCC_PLLRef));
265  NT_COMMON_REG->PLL_CTRL_bit.PLL_DIV = RCC_PLLInit_Struct->RCC_PLLDiv;
266  NT_COMMON_REG->PLL_OD = ((uint32_t)(RCC_PLLInit_Struct->RCC_PLLNO));
267  NT_COMMON_REG->PLL_NF = RCC_PLLInit_Struct->RCC_PLLNF - 2;
268  NT_COMMON_REG->PLL_NR = RCC_PLLInit_Struct->RCC_PLLNR - 2;
269 }
270 
278 void RCC_PLLStructInit(RCC_PLLInit_TypeDef* RCC_PLLInit_Struct)
279 {
280  RCC_PLLInit_Struct->RCC_PLLRef = RCC_PLLRef_XI_OSC;
281  RCC_PLLInit_Struct->RCC_PLLDiv = 0;
282  RCC_PLLInit_Struct->RCC_PLLNO = RCC_PLLNO_Disable;
283  RCC_PLLInit_Struct->RCC_PLLNF = 2;
284  RCC_PLLInit_Struct->RCC_PLLNR = 2;
285 }
286 
293 {
294  NT_COMMON_REG->PLL_CTRL = RCC_PLL_CTRL_Reset_Value;
295  NT_COMMON_REG->PLL_OD = RCC_PLL_OD_Reset_Value;
296  NT_COMMON_REG->PLL_NF = RCC_PLL_NF_Reset_Value;
297  NT_COMMON_REG->PLL_NR = RCC_PLL_NR_Reset_Value;
298 }
299 
308 {
309  /* Check the parameters */
310  assert_param(IS_FUNCTIONAL_STATE(State));
311 
312  if (State == DISABLE)
313  {
314  NT_COMMON_REG->PLL_CTRL_bit.PD = 0;
315  }
316  else if (State == ENABLE)
317  {
318  NT_COMMON_REG->PLL_CTRL_bit.PD = 1;
319  }
320 }
321 
337 {
338  /* Check the parameters */
339  assert_param(IS_RCC_PERIPH_CLK(RCC_PeriphClk));
340  assert_param(IS_FUNCTIONAL_STATE(State));
341 
342  if (State == ENABLE)
343  {
344  NT_COMMON_REG->APB_CLK |= RCC_PeriphClk;
345  }
346  else if (State == DISABLE)
347  {
348  NT_COMMON_REG->APB_CLK &= ~RCC_PeriphClk;
349  }
350 }
351 
360 {
361  uint32_t timeout;
362  OperationStatus status;
363 
364  /* Check the parameters */
365  assert_param(IS_RCC_SYS_CLK(RCC_SysClk));
366 
367  NT_COMMON_REG->SYS_CLK = ((uint32_t)RCC_SysClk);
368 
369  timeout = RCC_WaitClkChange(RCC_SysClk);
370 
371  if (timeout)
372  {
373  status = OK;
374  }
375  else
376  {
377  status = ERROR;
378  }
379 
380  return status;
381 }
382 
389 {
390  return((RCC_SysClk_TypeDef)((NT_COMMON_REG->SYS_CLK)>>SYS_CLK_CURR_SRC_Pos));
391 }
392 
403 {
404  /* Check the parameters */
405  assert_param(IS_RCC_USB_CLK(RCC_USBClk));
406  assert_param(IS_RCC_USB_FREQ(RCC_USBFreq));
407 
408  NT_COMMON_REG->USB_CTRL &= ~((1<<USB_CTRL_FSEL_Pos) | (1<<USB_CTRL_CLKSEL_Pos));
409  NT_COMMON_REG->USB_CTRL |= (RCC_USBFreq<<USB_CTRL_FSEL_Pos) | (RCC_USBClk<<USB_CTRL_CLKSEL_Pos);
410 }
411 
420 {
421  /* Check the parameters */
422  assert_param(IS_FUNCTIONAL_STATE(State));
423 
424  if (State == ENABLE)
425  {
426  NT_COMMON_REG->USB_CTRL_bit.CLKEN = 1;
427  }
428  else if (State == DISABLE)
429  {
430  NT_COMMON_REG->USB_CTRL_bit.CLKEN = 0;
431  }
432 }
433 
442 void RCC_UARTClkSel(NT_UART_TypeDef* UARTx, RCC_UARTClk_TypeDef RCC_UARTClk)
443 {
444  uint32_t offset;
445 
446  /* Check the parameters */
447  assert_param(IS_UART_ALL_PERIPH(UARTx));
448  assert_param(IS_RCC_UART_CLK(RCC_UARTClk));
449 
450  if (UARTx == NT_UART0)
451  {
452  offset = UART_SPI_CLK_SEL_SEL_UART0_Pos;
453  }
454  else if (UARTx == NT_UART1)
455  {
456  offset = UART_SPI_CLK_SEL_SEL_UART1_Pos;
457  }
458  else if (UARTx == NT_UART2)
459  {
460  offset = UART_SPI_CLK_SEL_SEL_UART2_Pos;
461  }
462  else /* (UARTx == NT_UART3) */
463  {
464  offset = UART_SPI_CLK_SEL_SEL_UART3_Pos;
465  }
466 
467  NT_COMMON_REG->UART_SPI_CLK_SEL &= ~(3<<offset);
468  NT_COMMON_REG->UART_SPI_CLK_SEL |= (RCC_UARTClk<<offset);
469 }
470 
482 void RCC_UARTClkDivConfig(NT_UART_TypeDef* UARTx, uint32_t DivVal, FunctionalState DivState)
483 {
484  uint32_t offset;
485 
486  /* Check the parameters */
487  assert_param(IS_UART_ALL_PERIPH(UARTx));
488  assert_param(IS_RCC_CLK_DIV(DivVal));
489  assert_param(IS_FUNCTIONAL_STATE(DivState));
490 
491  if (UARTx == NT_UART0)
492  {
493  offset = UART_CLK_DIVEN_UART0_Pos;
494  }
495  else if (UARTx == NT_UART1)
496  {
497  offset = UART_CLK_DIVEN_UART1_Pos;
498  }
499  else if (UARTx == NT_UART2)
500  {
501  offset = UART_CLK_DIVEN_UART2_Pos;
502  }
503  else /* (UARTx == NT_UART3) */
504  {
505  offset = UART_CLK_DIVEN_UART3_Pos;
506  }
507 
508  NT_COMMON_REG->UART_CLK &= ~(0x7F << offset);
509  NT_COMMON_REG->UART_CLK |= (DivVal << (offset+1)) | (DivState << offset);
510 }
511 
520 void RCC_UARTClkCmd(NT_UART_TypeDef* UARTx, FunctionalState State)
521 {
522  uint32_t offset;
523 
524  /* Check the parameters */
525  assert_param(IS_UART_ALL_PERIPH(UARTx));
526  assert_param(IS_FUNCTIONAL_STATE(State));
527 
528  if (UARTx == NT_UART0)
529  {
530  offset = UART_CLK_CLKEN_UART0_Pos;
531  }
532  else if (UARTx == NT_UART1)
533  {
534  offset = UART_CLK_CLKEN_UART1_Pos;
535  }
536  else if (UARTx == NT_UART2)
537  {
538  offset = UART_CLK_CLKEN_UART2_Pos;
539  }
540  else /* (UARTx == NT_UART3) */
541  {
542  offset = UART_CLK_CLKEN_UART3_Pos;
543  }
544 
545  if (State == ENABLE)
546  {
547  NT_COMMON_REG->UART_CLK |= (1 << offset);
548  }
549  else if (State == DISABLE)
550  {
551  NT_COMMON_REG->UART_CLK &= ~(1 << offset);
552  }
553 }
554 
563 void RCC_SPIClkSel(NT_SPI_TypeDef* SPIx, RCC_SPIClk_TypeDef RCC_SPIClk)
564 {
565  uint32_t offset;
566 
567  /* Check the parameters */
568  assert_param(IS_SPI_ALL_PERIPH(SPIx));
569  assert_param(IS_RCC_SPI_CLK(RCC_SPIClk));
570 
571  if (SPIx == NT_SPI0)
572  {
573  offset = UART_SPI_CLK_SEL_SEL_SPI0_Pos;
574  }
575  else if (SPIx == NT_SPI1)
576  {
577  offset = UART_SPI_CLK_SEL_SEL_SPI1_Pos;
578  }
579  else if (SPIx == NT_SPI2)
580  {
581  offset = UART_SPI_CLK_SEL_SEL_SPI2_Pos;
582  }
583  else /* (SPIx == NT_SPI3) */
584  {
585  offset = UART_SPI_CLK_SEL_SEL_SPI3_Pos;
586  }
587 
588  NT_COMMON_REG->UART_SPI_CLK_SEL &= ~(3<<offset);
589  NT_COMMON_REG->UART_SPI_CLK_SEL |= (RCC_SPIClk<<offset);
590 }
591 
592 
604 void RCC_SPIClkDivConfig(NT_SPI_TypeDef* SPIx, uint32_t DivVal, FunctionalState DivState)
605 {
606  uint32_t offset;
607 
608  /* Check the parameters */
609  assert_param(IS_SPI_ALL_PERIPH(SPIx));
610  assert_param(IS_RCC_CLK_DIV(DivVal));
611  assert_param(IS_FUNCTIONAL_STATE(DivState));
612 
613  if (SPIx == NT_SPI0)
614  {
615  offset = SPI_CLK_DIVEN_SPI0_Pos;
616  }
617  else if (SPIx == NT_SPI1)
618  {
619  offset = SPI_CLK_DIVEN_SPI1_Pos;
620  }
621  else if (SPIx == NT_SPI2)
622  {
623  offset = SPI_CLK_DIVEN_SPI2_Pos;
624  }
625  else /* (SPIx == NT_SPI3) */
626  {
627  offset = SPI_CLK_DIVEN_SPI3_Pos;
628  }
629 
630  NT_COMMON_REG->SPI_CLK &= ~(0x7F << offset);
631  NT_COMMON_REG->SPI_CLK |= (DivVal << (offset+1)) | (DivState << offset);
632 }
633 
642 void RCC_SPIClkCmd(NT_SPI_TypeDef* SPIx, FunctionalState State)
643 {
644  uint32_t offset;
645 
646  /* Check the parameters */
647  assert_param(IS_SPI_ALL_PERIPH(SPIx));
648  assert_param(IS_FUNCTIONAL_STATE(State));
649 
650  if (SPIx == NT_SPI0)
651  {
652  offset = SPI_CLK_CLKEN_SPI0_Pos;
653  }
654  else if (SPIx == NT_SPI1)
655  {
656  offset = SPI_CLK_CLKEN_SPI1_Pos;
657  }
658  else if (SPIx == NT_SPI2)
659  {
660  offset = SPI_CLK_CLKEN_SPI2_Pos;
661  }
662  else /* (SPIx == NT_SPI3) */
663  {
664  offset = SPI_CLK_CLKEN_SPI3_Pos;
665  }
666 
667  if (State == ENABLE)
668  {
669  NT_COMMON_REG->SPI_CLK |= (1 << offset);
670  }
671  else if (State == DISABLE)
672  {
673  NT_COMMON_REG->SPI_CLK &= ~(1 << offset);
674  }
675 }
676 
689 void RCC_ADCClkDivConfig(RCC_ADCClk_TypeDef RCC_ADCClk, uint32_t DivVal, FunctionalState DivState)
690 {
691  uint32_t offset;
692  volatile uint32_t* ctrl_reg;
693 
694  /* Check the parameters */
695  assert_param(IS_RCC_ADC_CLK(RCC_ADCClk));
696  assert_param(IS_RCC_CLK_DIV(DivVal));
697  assert_param(IS_FUNCTIONAL_STATE(DivState));
698 
699  if (RCC_ADCClk == RCC_ADCClk_0)
700  {
701  offset = ADC_CTRL1_DIVEN_ADC0_Pos;
702  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
703  }
704  else if (RCC_ADCClk == RCC_ADCClk_1)
705  {
706  offset = ADC_CTRL1_DIVEN_ADC1_Pos;
707  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
708  }
709  else if (RCC_ADCClk == RCC_ADCClk_2)
710  {
711  offset = ADC_CTRL1_DIVEN_ADC2_Pos;
712  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
713  }
714  else if (RCC_ADCClk == RCC_ADCClk_3)
715  {
716  offset = ADC_CTRL1_DIVEN_ADC3_Pos;
717  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
718  }
719  else if (RCC_ADCClk == RCC_ADCClk_4)
720  {
721  offset = ADC_CTRL2_DIVEN_ADC4_Pos;
722  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
723  }
724  else if (RCC_ADCClk == RCC_ADCClk_5)
725  {
726  offset = ADC_CTRL2_DIVEN_ADC5_Pos;
727  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
728  }
729  else if (RCC_ADCClk == RCC_ADCClk_6)
730  {
731  offset = ADC_CTRL2_DIVEN_ADC6_Pos;
732  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
733  }
734  else if (RCC_ADCClk == RCC_ADCClk_7)
735  {
736  offset = ADC_CTRL2_DIVEN_ADC7_Pos;
737  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
738  }
739  else if (RCC_ADCClk == RCC_ADCClk_8)
740  {
741  offset = ADC_CTRL3_DIVEN_ADC8_Pos;
742  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
743  }
744  else if (RCC_ADCClk == RCC_ADCClk_9)
745  {
746  offset = ADC_CTRL3_DIVEN_ADC9_Pos;
747  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
748  }
749  else if (RCC_ADCClk == RCC_ADCClk_10)
750  {
751  offset = ADC_CTRL3_DIVEN_ADC10_Pos;
752  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
753  }
754  else /* (RCC_ADCClk == RCC_ADCClk_11) */
755  {
756  offset = ADC_CTRL3_DIVEN_ADC11_Pos;
757  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
758  }
759 
760  *ctrl_reg &= ~(0x7F << offset);
761  *ctrl_reg |= (DivVal << (offset+1)) | (DivState << offset);
762 }
763 
774 {
775  uint32_t offset;
776  volatile uint32_t* ctrl_reg;
777 
778  /* Check the parameters */
779  assert_param(IS_RCC_ADC_CLK(RCC_ADCClk));
780  assert_param(IS_FUNCTIONAL_STATE(State));
781 
782  if (RCC_ADCClk == RCC_ADCClk_0)
783  {
784  offset = ADC_CTRL1_CLKEN_ADC0_Pos;
785  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
786  }
787  else if (RCC_ADCClk == RCC_ADCClk_1)
788  {
789  offset = ADC_CTRL1_CLKEN_ADC1_Pos;
790  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
791  }
792  else if (RCC_ADCClk == RCC_ADCClk_2)
793  {
794  offset = ADC_CTRL1_CLKEN_ADC2_Pos;
795  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
796  }
797  else if (RCC_ADCClk == RCC_ADCClk_3)
798  {
799  offset = ADC_CTRL1_CLKEN_ADC3_Pos;
800  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL1);
801  }
802  else if (RCC_ADCClk == RCC_ADCClk_4)
803  {
804  offset = ADC_CTRL2_CLKEN_ADC4_Pos;
805  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
806  }
807  else if (RCC_ADCClk == RCC_ADCClk_5)
808  {
809  offset = ADC_CTRL2_CLKEN_ADC5_Pos;
810  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
811  }
812  else if (RCC_ADCClk == RCC_ADCClk_6)
813  {
814  offset = ADC_CTRL2_CLKEN_ADC6_Pos;
815  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
816  }
817  else if (RCC_ADCClk == RCC_ADCClk_7)
818  {
819  offset = ADC_CTRL2_CLKEN_ADC7_Pos;
820  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL2);
821  }
822  else if (RCC_ADCClk == RCC_ADCClk_8)
823  {
824  offset = ADC_CTRL3_CLKEN_ADC8_Pos;
825  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
826  }
827  else if (RCC_ADCClk == RCC_ADCClk_9)
828  {
829  offset = ADC_CTRL3_CLKEN_ADC9_Pos;
830  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
831  }
832  else if (RCC_ADCClk == RCC_ADCClk_10)
833  {
834  offset = ADC_CTRL3_CLKEN_ADC10_Pos;
835  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
836  }
837  else /* (RCC_ADCClk == RCC_ADCClk_11) */
838  {
839  offset = ADC_CTRL3_CLKEN_ADC11_Pos;
840  ctrl_reg = &(NT_COMMON_REG->ADC_CTRL3);
841  }
842 
843  if (State == ENABLE)
844  {
845  *ctrl_reg |= (1 << offset);
846  }
847  else if (State == DISABLE)
848  {
849  *ctrl_reg &= ~(1 << offset);
850  }
851 
852 }
853 
864 {
865  volatile uint32_t* ctrl_reg;
866 
867  /* Check the parameters */
868  assert_param(IS_RCC_PERIPH_RST(RCC_PeriphRst));
869  assert_param(IS_FUNCTIONAL_STATE(State));
870 
871  if ((RCC_PeriphRst == RCC_PeriphRst_WD) ||
872  (RCC_PeriphRst == RCC_PeriphRst_I2C0) ||
873  (RCC_PeriphRst == RCC_PeriphRst_I2C1) ||
874  (RCC_PeriphRst == RCC_PeriphRst_USB) ||
875  (RCC_PeriphRst == RCC_PeriphRst_Timer0) ||
876  (RCC_PeriphRst == RCC_PeriphRst_Timer1) ||
877  (RCC_PeriphRst == RCC_PeriphRst_Timer2) ||
878  (RCC_PeriphRst == RCC_PeriphRst_UART0) ||
879  (RCC_PeriphRst == RCC_PeriphRst_UART1) ||
880  (RCC_PeriphRst == RCC_PeriphRst_UART2) ||
881  (RCC_PeriphRst == RCC_PeriphRst_UART3) ||
882  (RCC_PeriphRst == RCC_PeriphRst_SPI0) ||
883  (RCC_PeriphRst == RCC_PeriphRst_SPI1) ||
884  (RCC_PeriphRst == RCC_PeriphRst_SPI2) ||
885  (RCC_PeriphRst == RCC_PeriphRst_SPI3) ||
886  (RCC_PeriphRst == RCC_PeriphRst_ETH))
887  {
888  ctrl_reg = &(NT_COMMON_REG->PER_RST1);
889  }
890  else
891  {
892  ctrl_reg = &(NT_COMMON_REG->PER_RST2);
893  }
894 
895  if (State == ENABLE)
896  {
897  *ctrl_reg |= RCC_PeriphRst;
898  }
899  else if (State == DISABLE)
900  {
901  *ctrl_reg &= ~RCC_PeriphRst;
902  }
903 }
904 
921 /******************* (C) COPYRIGHT 2015 NIIET *****END OF FILE****/
RCC_UARTClk_TypeDef
Выбор источника тактирования для UART.
Definition: niietcm4_rcc.h:107
void RCC_PLLPowerDownCmd(FunctionalState State)
Управление режимом PowerDown PLL.
Definition: niietcm4_rcc.c:307
OperationStatus RCC_SysClkSel(RCC_SysClk_TypeDef RCC_SysClk)
Выбор источника для системного тактового сигнала.
Definition: niietcm4_rcc.c:359
void RCC_SPIClkCmd(NT_SPI_TypeDef *SPIx, FunctionalState State)
Включение тактирования SPI.
Definition: niietcm4_rcc.c:642
RCC_PLLRef_TypeDef
Выбор источника опорного сигнала PLL.
Definition: niietcm4_rcc.h:66
void RCC_ADCClkDivConfig(RCC_ADCClk_TypeDef RCC_ADCClk, uint32_t DivVal, FunctionalState DivState)
Настройка делителя тактового сигнала для выбранного ADC.
Definition: niietcm4_rcc.c:689
#define IS_RCC_PLL_REF(PLL_REF)
Макрос проверки аргументов типа RCC_PLLRef_TypeDef.
Definition: niietcm4_rcc.h:78
#define IS_RCC_PLL_NR(PLL_NR)
Макрос проверки значения опорного делителя PLL на попадание в допустимый диапазон.
Definition: niietcm4_rcc.h:399
RCC_ADCClk_TypeDef
Выбор модуля ADC для настройки его тактового сигнала.
Definition: niietcm4_rcc.h:183
#define IS_RCC_SYS_FREQ(SYS_FREQ)
Макрос проверки значения желаемой частоты при автонастройке в допустимый диапазон.
Definition: niietcm4_rcc.h:417
Файл содержит все прототипы функций для RCC (Reset & Clock Control).
#define IS_RCC_PLL_NO(PLL_NO)
Макрос проверки аргументов типа RCC_PLLNO_TypeDef.
Definition: niietcm4_rcc.h:99
#define RCC_PLL_OD_Reset_Value
Definition: niietcm4_rcc.c:55
#define IS_RCC_PLL_NF(PLL_NF)
Макрос проверки значения делителя ОС PLL на попадание в допустимый диапазон.
Definition: niietcm4_rcc.h:405
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:393
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:442
void GPIO_StructInit(GPIO_Init_TypeDef *GPIO_InitStruct)
Заполнение каждого члена структуры GPIO_InitStruct значениями по умолчанию.
#define IS_RCC_ADC_CLK(ADC_CLK)
Макрос проверки аргументов типа RCC_ADCClk_TypeDef.
Definition: niietcm4_rcc.h:203
void RCC_PeriphClkCmd(RCC_PeriphClk_TypeDef RCC_PeriphClk, FunctionalState State)
Включение тактирования выбранного блока периферии.
Definition: niietcm4_rcc.c:336
#define IS_RCC_USB_CLK(USB_CLK)
Макрос проверки аргументов типа RCC_USBClk_TypeDef.
Definition: niietcm4_rcc.h:159
#define IS_UART_ALL_PERIPH(PERIPH)
Макрос проверки аргументов типа NT_UART_TypeDef.
Definition: niietcm4.h:214
Структура инициализации PLL.
Definition: niietcm4_rcc.h:375
#define IS_RCC_SPI_CLK(SPI_CLK)
Макрос проверки аргументов типа RCC_SPIClk_TypeDef.
Definition: niietcm4_rcc.h:140
void RCC_ADCClkCmd(RCC_ADCClk_TypeDef RCC_ADCClk, FunctionalState State)
Включение тактирования ADC.
Definition: niietcm4_rcc.c:773
#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:176
RCC_USBClk_TypeDef
Выбор источника тактирования для USB.
Definition: niietcm4_rcc.h:149
void RCC_SPIClkSel(NT_SPI_TypeDef *SPIx, RCC_SPIClk_TypeDef RCC_SPIClk)
Настройка источника тактового сигнала для выбранного SPI.
Definition: niietcm4_rcc.c:563
RCC_PLLNO_TypeDef
Выходной делитель NO.
Definition: niietcm4_rcc.h:88
void RCC_PLLDeInit()
Устанавливает все регистры PLL значениями по умолчанию.
Definition: niietcm4_rcc.c:292
#define IS_RCC_SYS_CLK(SYS_CLK)
Макрос проверки аргументов типа RCC_SysClk_TypeDef.
Definition: niietcm4_rcc.h:236
RCC_SPIClk_TypeDef
Выбор источника тактирования для SPI.
Definition: niietcm4_rcc.h:128
void RCC_UARTClkCmd(NT_UART_TypeDef *UARTx, FunctionalState State)
Включение тактирования UART.
Definition: niietcm4_rcc.c:520
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:273
void RCC_SPIClkDivConfig(NT_SPI_TypeDef *SPIx, uint32_t DivVal, FunctionalState DivState)
Настройка делителя тактового сигнала для выбранного SPI.
Definition: niietcm4_rcc.c:604
GPIO_Out_TypeDef GPIO_Out
#define IS_RCC_PERIPH_RST(PERIPH_RST)
Макрос проверки аргументов типа RCC_PeriphRst_TypeDef.
Definition: niietcm4_rcc.h:335
Структура инициализации GPIO.
void RCC_UARTClkDivConfig(NT_UART_TypeDef *UARTx, uint32_t DivVal, FunctionalState DivState)
Настройка делителя тактового сигнала для выбранного UART.
Definition: niietcm4_rcc.c:482
RCC_PLLNO_TypeDef RCC_PLLNO
Definition: niietcm4_rcc.h:381
#define IS_RCC_CLK_DIV(CLK_DIV)
Макрос проверки значения делителя тактового сигнала на попадание в допустимый диапазон.
Definition: niietcm4_rcc.h:411
OperationStatus
Описывает коды возврата для функций при выполнении какой-либо операции.
Definition: niietcm4.h:173
RCC_USBFreq_TypeDef
Выбор фиксированной частоты на входе CLK_USB.
Definition: niietcm4_rcc.h:166
#define IS_RCC_UART_CLK(UART_CLK)
Макрос проверки аргументов типа RCC_UARTClk_TypeDef.
Definition: niietcm4_rcc.h:119
GPIO_Mode_TypeDef GPIO_Mode
RCC_PLLRef_TypeDef RCC_PLLRef
Definition: niietcm4_rcc.h:379
RCC_SysClk_TypeDef RCC_SysClkStatus()
Текущий источник системного тактового сигнала.
Definition: niietcm4_rcc.c:388
#define IS_FUNCTIONAL_STATE(STATE)
Макрос проверки аргументов типа FunctionalState.
Definition: niietcm4.h:167
RCC_PeriphRst_TypeDef
Управление сбросом периферийных блоков
Definition: niietcm4_rcc.h:293
void RCC_USBClkConfig(RCC_USBClk_TypeDef RCC_USBClk, RCC_USBFreq_TypeDef RCC_USBFreq)
Настройка источника тактового сигнала для USB.
Definition: niietcm4_rcc.c:402
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:256
#define RCC_CLK_CHANGE_TIMEOUT
Definition: niietcm4_rcc.h:52
RCC_PeriphClk_TypeDef
Управление тактированием периферийных блоков
Definition: niietcm4_rcc.h:249
#define EXT_OSC_VALUE
Определение частоты используемого внешнего тактового генератора.
Definition: niietcm4.h:73
void RCC_PLLStructInit(RCC_PLLInit_TypeDef *RCC_PLLInit_Struct)
Заполнение каждого члена структуры RCC_PLLInit_Struct значениями по умолчанию.
Definition: niietcm4_rcc.c:278
RCC_SysClk_TypeDef
Выбор источника системной частоты.
Definition: niietcm4_rcc.h:220
#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:863
void RCC_USBClkCmd(FunctionalState State)
Включение тактирования USB.
Definition: niietcm4_rcc.c:419