NIIETCM4 PD  v0.10.5
Драйвер периферии для микроконтроллеров на базе ядра ARM Cortex-M4
 Указатель Структуры данных Файлы Функции Переменные Перечисления Элементы перечислений Группы Страницы
niietcm4_adc.c
См. документацию.
1 
30 /* Includes ------------------------------------------------------------------*/
31 #include "niietcm4_adc.h"
32 
109 {
110  assert_param(IS_ADC_MODULE(ADC_Module));
111  assert_param(IS_FUNCTIONAL_STATE(State));
112 
113  NT_ADC->PP_bit[(uint32_t)ADC_Module].ENA = (uint32_t)State;
114 }
115 
124 {
125  assert_param(IS_ADC_MODULE(ADC_Module));
126 
127  if (ADC_Module == ADC_Module_0)
128  {
129  NT_ADC->SPC0_bit.PHASE0 = 0;
130  NT_ADC->SAC_bit.AVG0 = 0;
131  }
132  else if (ADC_Module == ADC_Module_1)
133  {
134  NT_ADC->SPC0_bit.PHASE1 = 0;
135  NT_ADC->SAC_bit.AVG1 = 0;
136  }
137  else if (ADC_Module == ADC_Module_2)
138  {
139  NT_ADC->SPC1_bit.PHASE2 = 0;
140  NT_ADC->SAC_bit.AVG2 = 0;
141  }
142  else if (ADC_Module == ADC_Module_3)
143  {
144  NT_ADC->SPC1_bit.PHASE3 = 0;
145  NT_ADC->SAC_bit.AVG3 = 0;
146  }
147  else if (ADC_Module == ADC_Module_4)
148  {
149  NT_ADC->SPC2_bit.PHASE4 = 0;
150  NT_ADC->SAC_bit.AVG4 = 0;
151  }
152  else if (ADC_Module == ADC_Module_5)
153  {
154  NT_ADC->SPC2_bit.PHASE5 = 0;
155  NT_ADC->SAC_bit.AVG5 = 0;
156  }
157  else if (ADC_Module == ADC_Module_6)
158  {
159  NT_ADC->SPC3_bit.PHASE6 = 0;
160  NT_ADC->SAC_bit.AVG6 = 0;
161  }
162  else if (ADC_Module == ADC_Module_7)
163  {
164  NT_ADC->SPC3_bit.PHASE7 = 0;
165  NT_ADC->SAC_bit.AVG7 = 0;
166  }
167  else if (ADC_Module == ADC_Module_8)
168  {
169  NT_ADC->SPC4_bit.PHASE8 = 0;
170  NT_ADC->RICNT_bit.AVG8 = 0;
171  }
172  else if (ADC_Module == ADC_Module_9)
173  {
174  NT_ADC->SPC4_bit.PHASE9 = 0;
175  NT_ADC->RICNT_bit.AVG9 = 0;
176  }
177  else if (ADC_Module == ADC_Module_10)
178  {
179  NT_ADC->SPC5_bit.PHASE10 = 0;
180  NT_ADC->RICNT_bit.AVG10 = 0;
181  }
182  else if (ADC_Module == ADC_Module_11)
183  {
184  NT_ADC->SPC5_bit.PHASE11 = 0;
185  NT_ADC->RICNT_bit.AVG11 = 0;
186  }
187 
188  NT_ADC->PP_bit[(uint32_t)ADC_Module].OM = 0;
189 }
190 
199 void ADC_Init(ADC_Module_TypeDef ADC_Module, ADC_Init_TypeDef* ADC_InitStruct)
200 {
201  assert_param(IS_ADC_MODULE(ADC_Module));
202  assert_param(IS_ADC_RESOLUTION(ADC_InitStruct->ADC_Resolution));
203  assert_param(IS_ADC_MEASURE(ADC_InitStruct->ADC_Measure_A));
204  assert_param(IS_ADC_MEASURE(ADC_InitStruct->ADC_Measure_B));
205  assert_param(IS_ADC_PHASE(ADC_InitStruct->ADC_Phase));
206  assert_param(IS_ADC_AVERAGE(ADC_InitStruct->ADC_Average));
207  assert_param(IS_ADC_MODE(ADC_InitStruct->ADC_Mode));
208 
209  if (ADC_Module == ADC_Module_0)
210  {
211  NT_ADC->SPC0_bit.PHASE0 = ADC_InitStruct->ADC_Phase;
212  NT_ADC->SAC_bit.AVG0 = ADC_InitStruct->ADC_Average;
213  }
214  else if (ADC_Module == ADC_Module_1)
215  {
216  NT_ADC->SPC0_bit.PHASE1 = ADC_InitStruct->ADC_Phase;
217  NT_ADC->SAC_bit.AVG1 = ADC_InitStruct->ADC_Average;
218  }
219  else if (ADC_Module == ADC_Module_2)
220  {
221  NT_ADC->SPC1_bit.PHASE2 = ADC_InitStruct->ADC_Phase;
222  NT_ADC->SAC_bit.AVG2 = ADC_InitStruct->ADC_Average;
223  }
224  else if (ADC_Module == ADC_Module_3)
225  {
226  NT_ADC->SPC1_bit.PHASE3 = ADC_InitStruct->ADC_Phase;
227  NT_ADC->SAC_bit.AVG3 = ADC_InitStruct->ADC_Average;
228  }
229  else if (ADC_Module == ADC_Module_4)
230  {
231  NT_ADC->SPC2_bit.PHASE4 = ADC_InitStruct->ADC_Phase;
232  NT_ADC->SAC_bit.AVG4 = ADC_InitStruct->ADC_Average;
233  }
234  else if (ADC_Module == ADC_Module_5)
235  {
236  NT_ADC->SPC2_bit.PHASE5 = ADC_InitStruct->ADC_Phase;
237  NT_ADC->SAC_bit.AVG5 = ADC_InitStruct->ADC_Average;
238  }
239  else if (ADC_Module == ADC_Module_6)
240  {
241  NT_ADC->SPC3_bit.PHASE6 = ADC_InitStruct->ADC_Phase;
242  NT_ADC->SAC_bit.AVG6 = ADC_InitStruct->ADC_Average;
243  }
244  else if (ADC_Module == ADC_Module_7)
245  {
246  NT_ADC->SPC3_bit.PHASE7 = ADC_InitStruct->ADC_Phase;
247  NT_ADC->SAC_bit.AVG7 = ADC_InitStruct->ADC_Average;
248  }
249  else if (ADC_Module == ADC_Module_8)
250  {
251  NT_ADC->SPC4_bit.PHASE8 = ADC_InitStruct->ADC_Phase;
252  NT_ADC->RICNT_bit.AVG8 = ADC_InitStruct->ADC_Average;
253  }
254  else if (ADC_Module == ADC_Module_9)
255  {
256  NT_ADC->SPC4_bit.PHASE9 = ADC_InitStruct->ADC_Phase;
257  NT_ADC->RICNT_bit.AVG9 = ADC_InitStruct->ADC_Average;
258  }
259  else if (ADC_Module == ADC_Module_10)
260  {
261  NT_ADC->SPC5_bit.PHASE10 = ADC_InitStruct->ADC_Phase;
262  NT_ADC->RICNT_bit.AVG10 = ADC_InitStruct->ADC_Average;
263  }
264  else if (ADC_Module == ADC_Module_11)
265  {
266  NT_ADC->SPC5_bit.PHASE11 = ADC_InitStruct->ADC_Phase;
267  NT_ADC->RICNT_bit.AVG11 = ADC_InitStruct->ADC_Average;
268  }
269 
270  NT_ADC->PP_bit[(uint32_t)ADC_Module].OM = (((uint32_t)ADC_InitStruct->ADC_Measure_B)<<6) |
271  (((uint32_t)ADC_InitStruct->ADC_Measure_A)<<4) |
272  (((uint32_t)ADC_InitStruct->ADC_Resolution)<<3) |
273  (((uint32_t)ADC_InitStruct->ADC_Mode)<<0);
274 }
275 
283 void ADC_StructInit(ADC_Init_TypeDef* ADC_InitStruct)
284 {
285  ADC_InitStruct->ADC_Resolution = ADC_Resolution_12bit;
286  ADC_InitStruct->ADC_Measure_A = ADC_Measure_Single;
287  ADC_InitStruct->ADC_Measure_B = ADC_Measure_Single;
288  ADC_InitStruct->ADC_Phase = 0;
289  ADC_InitStruct->ADC_Average = ADC_Average_Disable;
290  ADC_InitStruct->ADC_Mode = ADC_Mode_Powerdown;
291 }
292 
301 {
302  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
303 
304  NT_ADC->DCCMP_bit[(uint32_t)ADC_DC_Module].COMP0 = 0;
305  NT_ADC->DCCMP_bit[(uint32_t)ADC_DC_Module].COMP1 = 0;
306  NT_ADC->DCCTL_bit[(uint32_t)ADC_DC_Module].CHNL = 0x1F; // т.к. 0 = выбран нулевой канал, то нужно перевести в запрещенное состояние
307  NT_ADC->DCCTL_bit[(uint32_t)ADC_DC_Module].CTC = 0;
308  NT_ADC->DCCTL_bit[(uint32_t)ADC_DC_Module].CTM = 0;
309 }
310 
319 void ADC_DC_Init(ADC_DC_Module_TypeDef ADC_DC_Module, ADC_DC_Init_TypeDef* ADC_DC_InitStruct)
320 {
321  assert_param(IS_ADC_DC(ADC_DC_Module));
322  assert_param(IS_ADC_DC_THRESHOLD(ADC_DC_InitStruct->ADC_DC_ThresholdLow));
323  assert_param(IS_ADC_DC_THRESHOLD(ADC_DC_InitStruct->ADC_DC_ThresholdHigh));
324  assert_param(IS_ADC_DC_CHANNEL(ADC_DC_InitStruct->ADC_DC_Channel));
325  assert_param(IS_ADC_DC_MODE(ADC_DC_InitStruct->ADC_DC_Mode));
326  assert_param(IS_ADC_DC_CONDITION(ADC_DC_InitStruct->ADC_DC_Condition));
327 
328  NT_ADC->DCCMP_bit[(uint32_t)ADC_DC_Module].COMP0 = ADC_DC_InitStruct->ADC_DC_ThresholdLow;
329  NT_ADC->DCCMP_bit[(uint32_t)ADC_DC_Module].COMP1 = ADC_DC_InitStruct->ADC_DC_ThresholdHigh;
330  NT_ADC->DCCTL_bit[(uint32_t)ADC_DC_Module].CHNL = (uint32_t)ADC_DC_InitStruct->ADC_DC_Channel;
331  NT_ADC->DCCTL_bit[(uint32_t)ADC_DC_Module].CTC = (uint32_t)ADC_DC_InitStruct->ADC_DC_Condition;
332  NT_ADC->DCCTL_bit[(uint32_t)ADC_DC_Module].CTM = (uint32_t)ADC_DC_InitStruct->ADC_DC_Mode;
333 }
334 
342 void ADC_DC_StructInit(ADC_DC_Init_TypeDef* ADC_DC_InitStruct)
343 {
344  ADC_DC_InitStruct->ADC_DC_ThresholdLow = 0;
345  ADC_DC_InitStruct->ADC_DC_ThresholdHigh = 0;
346  ADC_DC_InitStruct->ADC_DC_Channel = ADC_DC_Channel_None;
347  ADC_DC_InitStruct->ADC_DC_Mode = ADC_DC_Mode_Single;
348  ADC_DC_InitStruct->ADC_DC_Condition = ADC_DC_Condition_Low;
349 }
350 
359 {
360  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
361 
362  if (ADC_SEQ_Module == ADC_SEQ_Module_0)
363  {
364  NT_ADC->EMUX_bit.EM0 = 0;
365  NT_ADC->PSSI_bit.SS0 = 0;
366  }
367  else if (ADC_SEQ_Module == ADC_SEQ_Module_1)
368  {
369  NT_ADC->EMUX_bit.EM1 = 0;
370  NT_ADC->PSSI_bit.SS1 = 0;
371  }
372  else if (ADC_SEQ_Module == ADC_SEQ_Module_2)
373  {
374  NT_ADC->EMUX_bit.EM2 = 0;
375  NT_ADC->PSSI_bit.SS2 = 0;
376  }
377  else if (ADC_SEQ_Module == ADC_SEQ_Module_3)
378  {
379  NT_ADC->EMUX_bit.EM3 = 0;
380  NT_ADC->PSSI_bit.SS3 = 0;
381  }
382  else if (ADC_SEQ_Module == ADC_SEQ_Module_4)
383  {
384  NT_ADC->EMUX_bit.EM4 = 0;
385  NT_ADC->PSSI_bit.SS4 = 0;
386  }
387  else if (ADC_SEQ_Module == ADC_SEQ_Module_5)
388  {
389  NT_ADC->EMUX_bit.EM5 = 0;
390  NT_ADC->PSSI_bit.SS5 = 0;
391  }
392  else if (ADC_SEQ_Module == ADC_SEQ_Module_6)
393  {
394  NT_ADC->EMUX_bit.EM6 = 0;
395  NT_ADC->PSSI_bit.SS6 = 0;
396  }
397  else if (ADC_SEQ_Module == ADC_SEQ_Module_7)
398  {
399  NT_ADC->EMUX_bit.EM7 = 0;
400  NT_ADC->PSSI_bit.SS7 = 0;
401  }
402 
403  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].CTL_bit.RCNT = 0;
404  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].TMR_bit.TMR = 2;
405  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].DCP = 0;
406  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].MUX = 0;
407 }
408 
418 void ADC_SEQ_Init(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, ADC_SEQ_Init_TypeDef* ADC_SEQ_InitStruct)
419 {
420  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
421  assert_param(IS_ADC_SEQ_START_EVENT(ADC_SEQ_InitStruct->ADC_SEQ_StartEvent));
422  assert_param(IS_FUNCTIONAL_STATE(ADC_SEQ_InitStruct->ADC_SEQ_SWReqEn));
423  assert_param(IS_ADC_CHANNEL(ADC_SEQ_InitStruct->ADC_Channels));
424  assert_param(IS_ADC_SEQ_CONVERSION_COUNT(ADC_SEQ_InitStruct->ADC_SEQ_ConversionCount));
425  assert_param(IS_ADC_SEQ_CONVERSION_DELAY(ADC_SEQ_InitStruct->ADC_SEQ_ConversionDelay));
426  assert_param(IS_ADC_DC(ADC_SEQ_InitStruct->ADC_SEQ_DC));
427 
428  NT_ADC->EMUX &= ~(0xF<<((uint32_t)ADC_SEQ_Module*4));
429  NT_ADC->EMUX |= ((uint32_t)ADC_SEQ_InitStruct->ADC_SEQ_StartEvent)<<((uint32_t)ADC_SEQ_Module*4);
430 
431  if (ADC_SEQ_InitStruct->ADC_SEQ_SWReqEn == ENABLE)
432  {
433  NT_ADC->PSSI |= 1<<((uint32_t)ADC_SEQ_Module);
434  }
435  else
436  {
437  NT_ADC->PSSI &= ~(1<<((uint32_t)ADC_SEQ_Module));
438  }
439 
440  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].CTL_bit.RCNT = (uint32_t)(ADC_SEQ_InitStruct->ADC_SEQ_ConversionCount-1);
441  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].TMR_bit.TMR = (uint32_t)ADC_SEQ_InitStruct->ADC_SEQ_ConversionDelay;
442  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].DCP = (uint32_t)ADC_SEQ_InitStruct->ADC_SEQ_DC;
443  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].MUX = (uint32_t)ADC_SEQ_InitStruct->ADC_Channels;
444 }
445 
453 void ADC_SEQ_StructInit(ADC_SEQ_Init_TypeDef* ADC_SEQ_InitStruct)
454 {
455  ADC_SEQ_InitStruct->ADC_SEQ_StartEvent = ADC_SEQ_StartEvent_SWReq;
456  ADC_SEQ_InitStruct->ADC_SEQ_SWReqEn = ENABLE;
457  ADC_SEQ_InitStruct->ADC_Channels = ADC_Channel_None;
458  ADC_SEQ_InitStruct->ADC_SEQ_ConversionCount = 1;
459  ADC_SEQ_InitStruct->ADC_SEQ_ConversionDelay = 2;
460  ADC_SEQ_InitStruct->ADC_SEQ_DC = ADC_DC_None;
461 }
462 
473 {
474  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
475  assert_param(IS_ADC_SEQ_FIFO_LEVEL(ADC_SEQ_FIFOLevel));
476 
477  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].CTL_bit.WMARK = (uint32_t)ADC_SEQ_FIFOLevel;
478 }
479 
490 {
491  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
492  assert_param(IS_FUNCTIONAL_STATE(State));
493 
494  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].CTL_bit.DMAEN = (uint32_t)State;
495 }
496 
506 {
507  FlagStatus Status;
508 
509  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
510 
511  if (NT_ADC->OSTAT & (1<<((uint32_t)ADC_SEQ_Module + 16))) // в первых 16 - флаги заполнения буфера секвенсора
512  {
513  Status = Flag_SET;
514  }
515  else
516  {
517  Status = Flag_CLEAR;
518  }
519 
520  return Status;
521 }
522 
531 {
532  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
533 
534  NT_ADC->OSTAT = 1<<((uint32_t)ADC_SEQ_Module + 16);
535 }
536 
547 {
548  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
549  assert_param(IS_FUNCTIONAL_STATE(State));
550 
551  NT_ADC->DCCTL_bit[(uint32_t)ADC_DC_Module].CIE = (uint32_t)State;
552 }
553 
564 {
565  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
566  assert_param(IS_FUNCTIONAL_STATE(State));
567 
568  if (State == ENABLE)
569  {
570  NT_ADC->IM |= 1<<((uint32_t)ADC_DC_Module + 8); // первые 8 - это секвенсоры
571  }
572  else /* if (State == DISABLE) */
573  {
574  NT_ADC->IM &= ~(1<<((uint32_t)ADC_DC_Module + 8)); // первые 8 - это секвенсоры
575  }
576 }
577 
590 {
591  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
592  assert_param(IS_FUNCTIONAL_STATE(State));
593 
594  //разрешение/запрещение генерации сигнала прерывания компаратору
595  ADC_DC_ITGenCmd(ADC_DC_Module, State);
596 
597  //маскирование сигнала прерывания для попадания внутрь NVIC
598  ADC_DC_ITMaskCmd(ADC_DC_Module, State);
599 }
600 
613 void ADC_DC_ITConfig(ADC_DC_Module_TypeDef ADC_DC_Module, ADC_DC_Mode_TypeDef ADC_DC_Mode, ADC_DC_Condition_TypeDef ADC_DC_Condition)
614 {
615  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
616  assert_param(IS_ADC_DC_MODE(ADC_DC_Mode));
617  assert_param(IS_ADC_DC_CONDITION(ADC_DC_Condition));
618 
619  NT_ADC->DCCTL_bit[(uint32_t)ADC_DC_Module].CIC = (uint32_t)ADC_DC_Condition;
620  NT_ADC->DCCTL_bit[(uint32_t)ADC_DC_Module].CIM = (uint32_t)ADC_DC_Mode;
621 }
622 
631 {
632  FlagStatus Status;
633 
634  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
635 
636  if (NT_ADC->RIS & (1<<((uint32_t)ADC_DC_Module + 8)))
637  {
638  Status = Flag_SET;
639  }
640  else
641  {
642  Status = Flag_CLEAR;
643  }
644 
645  return Status;
646 }
647 
656 {
657  FlagStatus Status;
658 
659  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
660 
661  if (NT_ADC->ISC & (1<<((uint32_t)ADC_DC_Module + 8)))
662  {
663  Status = Flag_SET;
664  }
665  else
666  {
667  Status = Flag_CLEAR;
668  }
669 
670  return Status;
671 }
672 
682 {
683  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
684 
685  NT_ADC->ISC = 1<<((uint32_t)ADC_DC_Module + 8); // первые 8 - это секвенсоры
686 }
687 
698 {
699  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
700  assert_param(IS_FUNCTIONAL_STATE(State));
701 
702  if (State == ENABLE)
703  {
704  NT_ADC->IM |= 1<<((uint32_t)ADC_SEQ_Module); // первые 8 - это секвенсоры
705  }
706  else /* if (State == DISABLE) */
707  {
708  NT_ADC->IM &= ~(1<<((uint32_t)ADC_SEQ_Module)); // первые 8 - это секвенсоры
709  }
710 }
711 
725 void ADC_SEQ_ITConfig(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, uint32_t ADC_SEQ_ITRate, FunctionalState ADC_SEQ_ITCountSEQRst)
726 {
727  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
728  assert_param(IS_ADC_SEQ_IT_RATE(ADC_SEQ_ITRate));
729  assert_param(IS_FUNCTIONAL_STATE(ADC_SEQ_ITCountSEQRst));
730 
731  if (ADC_SEQ_ITCountSEQRst == ENABLE)
732  {
733  NT_ADC->RICNT |= 1<<((uint32_t)ADC_SEQ_Module + 16); // первые 16 - это усреднители 8-11
734  }
735  else /* if (State == DISABLE) */
736  {
737  NT_ADC->RICNT &= ~(1<<((uint32_t)ADC_SEQ_Module + 16)); // первые 16 - это усреднители 8-11
738  }
739 
740  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].CTL_bit.ICNT = ADC_SEQ_ITRate - 1;
741 }
742 
751 {
752  uint32_t ITCount;
753 
754  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
755 
756  ITCount = NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].OP_bit.ICNT;
757 
758  return ITCount;
759 }
760 
769 {
770  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
771 
772  NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].OP_bit.ICNT = 1;
773 }
774 
783 {
784  FlagStatus Status;
785 
786  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
787 
788  if (NT_ADC->RIS & (1<<((uint32_t)ADC_SEQ_Module)))
789  {
790  Status = Flag_SET;
791  }
792  else
793  {
794  Status = Flag_CLEAR;
795  }
796 
797  return Status;
798 }
799 
808 {
809  FlagStatus Status;
810 
811  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
812 
813  if (NT_ADC->ISC & (1<<((uint32_t)ADC_SEQ_Module)))
814  {
815  Status = Flag_SET;
816  }
817  else
818  {
819  Status = Flag_CLEAR;
820  }
821 
822  return Status;
823 }
824 
833 {
834  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
835 
836  NT_ADC->ISC = 1<<((uint32_t)ADC_SEQ_Module);
837 }
838 
849 {
850  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
851  assert_param(IS_FUNCTIONAL_STATE(State));
852 
853  if (State == ENABLE)
854  {
855  NT_ADC->ACTSS |= 1<<((uint32_t)ADC_SEQ_Module);
856  }
857  else /* if (State == DISABLE) */
858  {
859  NT_ADC->ACTSS &= ~(1<<((uint32_t)ADC_SEQ_Module));
860  }
861 }
862 
869 {
870  NT_ADC->PSSI_bit.GSYNC = 1;
871 }
872 
881 {
882  uint32_t Data;
883 
884  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
885 
886  Data = NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].FIFO_bit.DATA;
887 
888  return Data;
889 }
890 
899 {
900  uint32_t Count;
901 
902  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
903 
904  Count = NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].OP_bit.RCNT;
905 
906  return Count;
907 }
908 
917 {
918  uint32_t Load;
919 
920  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
921 
922  Load = NT_ADC->SEQ[(uint32_t)ADC_SEQ_Module].FSTAT_bit.FLOAD;
923 
924  return Load;
925 }
926 
937 {
938  FlagStatus Status;
939 
940  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
941 
942  if (NT_ADC->OSTAT & (1<<((uint32_t)ADC_SEQ_Module)))
943  {
944  Status = Flag_SET;
945  }
946  else
947  {
948  Status = Flag_CLEAR;
949  }
950 
951  return Status;
952 }
953 
962 {
963  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
964 
965  NT_ADC->OSTAT = 1<<((uint32_t)ADC_SEQ_Module);
966 }
967 
977 {
978  FlagStatus Status;
979 
980  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
981 
982  if (NT_ADC->USTAT & (1<<((uint32_t)ADC_SEQ_Module)))
983  {
984  Status = Flag_SET;
985  }
986  else
987  {
988  Status = Flag_CLEAR;
989  }
990 
991  return Status;
992 }
993 
1002 {
1003  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
1004 
1005  NT_ADC->USTAT = 1<<((uint32_t)ADC_SEQ_Module);
1006 }
1007 
1018 {
1019  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
1020  assert_param(IS_FUNCTIONAL_STATE(State));
1021 
1022  NT_ADC->DCCTL_bit[(uint32_t)ADC_DC_Module].CTE = (uint32_t)State;
1023 }
1024 
1034 {
1035  uint32_t Value;
1036 
1037  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
1038 
1039  Value = NT_ADC->DCVAL_bit[(uint32_t)ADC_DC_Module].VAL;
1040 
1041  return Value;
1042 }
1043 
1052 {
1053  FlagStatus Status;
1054 
1055  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
1056 
1057  if (NT_ADC->DCRTC & (1<<((uint32_t)ADC_DC_Module)))
1058  {
1059  Status = Flag_SET;
1060  }
1061  else
1062  {
1063  Status = Flag_CLEAR;
1064  }
1065 
1066  return Status;
1067 }
1068 
1080 {
1081  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
1082 
1083  // чтобы сбросить 0 и 1 компараторы, нужно писать в биты 10 и 11 компараторов соответственно
1084  if ((ADC_DC_Module == ADC_DC_Module_0) |
1085  (ADC_DC_Module == ADC_DC_Module_1))
1086  {
1087  ADC_DC_Module = (ADC_DC_Module_TypeDef)((uint32_t)ADC_DC_Module + 10);
1088  }
1089 
1090  NT_ADC->DCRTC = 1<<((uint32_t)ADC_DC_Module + 8);
1091 }
1092 
1109 /******************* (C) COPYRIGHT 2015 NIIET *****END OF FILE****/
ADC_DC_Condition_TypeDef ADC_DC_Condition
Definition: niietcm4_adc.h:609
void ADC_SEQ_SWReq(void)
Программный запуск измерений всех разрешенных секвенсоров.
Definition: niietcm4_adc.c:868
ADC_DC_Mode_TypeDef
Режим срабатывания компаратора.
Definition: niietcm4_adc.h:330
#define IS_ADC_DC_CHANNEL(CHANNEL)
Макрос проверки аргументов типа ADC_DC_Channel_TypeDef.
Definition: niietcm4_adc.h:300
FunctionalState ADC_SEQ_SWReqEn
Definition: niietcm4_adc.h:621
ADC_SEQ_Module_TypeDef
Выбор модуля секвенсора.
Definition: niietcm4_adc.h:456
#define IS_ADC_PHASE(PHASE)
Проверка значения задержки начала преобразования модулем АЦП после запуска модуля секвенсором на попа...
Definition: niietcm4_adc.h:189
FlagStatus ADC_SEQ_FIFOFullStatus(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Проверка флага заполнения буффера секвенсора. Если флаг установлен, то значит что буффер заполнен и в...
Definition: niietcm4_adc.c:936
#define IS_ADC_DC_CONDITION(CONDITION)
Макрос проверки аргументов типа ADC_DC_Condition_TypeDef.
Definition: niietcm4_adc.h:362
void ADC_DC_Init(ADC_DC_Module_TypeDef ADC_DC_Module, ADC_DC_Init_TypeDef *ADC_DC_InitStruct)
Инициализирует выбранный модуль цифрового компаратора согласно параметрам структуры ADC_DC_InitStruct...
Definition: niietcm4_adc.c:319
FlagStatus ADC_SEQ_FIFOEmptyStatus(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Проверка флага пустоты буффера секвенсора. Флаг установлен когда буфер полностью пуст.
Definition: niietcm4_adc.c:976
uint32_t ADC_SEQ_GetConversionCount(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Получение количества измерений, проведенных модулями АЦП с момента запуска секвенсора.
Definition: niietcm4_adc.c:898
ADC_SEQ_StartEvent_TypeDef ADC_SEQ_StartEvent
Definition: niietcm4_adc.h:619
void ADC_DC_ITCmd(ADC_DC_Module_TypeDef ADC_DC_Module, FunctionalState State)
Включение прерывания компаратора и одновременное маскирование сигнала этого прерывания. При этом, эти же действия можно выполнить путем ручного вызовова соответствующих функций: ADC_DC_ITGenCmd и ADC_DC_ITMaskCmd.
Definition: niietcm4_adc.c:589
#define IS_ADC_SEQ_MODULE(MODULE)
Макрос проверки аргументов типа ADC_SEQ_Module_TypeDef.
Definition: niietcm4_adc.h:472
uint32_t ADC_SEQ_ConversionCount
Definition: niietcm4_adc.h:625
uint32_t ADC_SEQ_GetFIFOData(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Получение результата измерений из буффера секвенсора.
Definition: niietcm4_adc.c:880
#define IS_ADC_DC_MODULE(MODULE)
Макрос проверки аргументов типа ADC_DC_Module_TypeDef.
Definition: niietcm4_adc.h:427
#define IS_ADC_SEQ_FIFO_LEVEL(FIFO_LEVEL)
Макрос проверки аргументов типа ADC_SEQ_FIFOLevel_TypeDef.
Definition: niietcm4_adc.h:384
void ADC_DC_ITConfig(ADC_DC_Module_TypeDef ADC_DC_Module, ADC_DC_Mode_TypeDef ADC_DC_Mode, ADC_DC_Condition_TypeDef ADC_DC_Condition)
Настройка условия вызова прерывания цифрового компаратора. Условия вызова прерывания и условия срабат...
Definition: niietcm4_adc.c:613
#define IS_ADC_SEQ_IT_RATE(IT_RATE)
Проверка значения количества перезапусков модулей АЦП секвенсором после которого генерируется прерыва...
Definition: niietcm4_adc.h:169
ADC_Mode_TypeDef ADC_Mode
Definition: niietcm4_adc.h:588
#define IS_ADC_SEQ_START_EVENT(START_EVENT)
Макрос проверки аргументов типа ADC_SEQ_StartEvent_TypeDef.
Definition: niietcm4_adc.h:222
#define IS_ADC_AVERAGE(AVERAGE)
Макрос проверки аргументов типа ADC_Average_TypeDef.
Definition: niietcm4_adc.h:255
ADC_DC_Module_TypeDef
Выбор модуля цифрового компаратора.
Definition: niietcm4_adc.h:395
#define IS_ADC_CHANNEL(CHANNEL)
Макрос проверки попадания масок каналов в допустимый диапазон.
Definition: niietcm4_adc.h:86
void ADC_DC_TrigStatusClear(ADC_DC_Module_TypeDef ADC_DC_Module)
Cброс выходного триггера цифрового компаратора.
ADC_Measure_TypeDef ADC_Measure_B
Definition: niietcm4_adc.h:582
uint32_t ADC_DC_GetLastData(ADC_DC_Module_TypeDef ADC_DC_Module)
Значение результата измерения, которое последним использовалось компаратором при проверке на соответс...
uint32_t ADC_Phase
Definition: niietcm4_adc.h:584
void ADC_SEQ_FIFOEmptyStatusClear(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Cброс флага пустоты буффера секвенсора.
void ADC_SEQ_Cmd(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, FunctionalState State)
Включение секвенсора.
Definition: niietcm4_adc.c:848
#define ADC_Channel_None
Definition: niietcm4_adc.h:56
void ADC_SEQ_DMAErrorStatusClear(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Сброс статуса ошибки DMA.
Definition: niietcm4_adc.c:530
void ADC_Init(ADC_Module_TypeDef ADC_Module, ADC_Init_TypeDef *ADC_InitStruct)
Инициализирует выбранный модуль АЦП согласно параметрам структуры ADC_InitStruct. ...
Definition: niietcm4_adc.c:199
#define ADC_DC_None
Definition: niietcm4_adc.h:96
void ADC_SEQ_ITConfig(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, uint32_t ADC_SEQ_ITRate, FunctionalState ADC_SEQ_ITCountSEQRst)
Настройка вызова прерывания секвенсора.
Definition: niietcm4_adc.c:725
FlagStatus ADC_DC_TrigStatus(ADC_DC_Module_TypeDef ADC_DC_Module)
Проверка состояния выходного триггера компаратора.
void ADC_SEQ_DMACmd(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, FunctionalState State)
Включает для выбранного секвенсора генерирование запросов DMA.
Definition: niietcm4_adc.c:489
FlagStatus ADC_SEQ_DMAErrorStatus(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Проверка статуса ошибки, когда при наличии двух обрабатываемых запросов DMA от выбранного секвенсора...
Definition: niietcm4_adc.c:505
void ADC_SEQ_ITStatusClear(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Общий сброс флагов прерывания секвенсора. Сбрасывает как маскированные, так и немаскированные флаги...
Definition: niietcm4_adc.c:832
ADC_Module_TypeDef
Выбор модуля АЦП.
Definition: niietcm4_adc.h:485
#define IS_ADC_DC_MODE(MODE)
Макрос проверки аргументов типа ADC_DC_Mode_TypeDef.
Definition: niietcm4_adc.h:342
void ADC_SEQ_StructInit(ADC_SEQ_Init_TypeDef *ADC_SEQ_InitStruct)
Заполнение каждого члена структуры ADC_SEQ_InitStruct значениями по умолчанию.
Definition: niietcm4_adc.c:453
#define IS_ADC_MODE(MODE)
Макрос проверки аргументов типа ADC_Mode_TypeDef.
Definition: niietcm4_adc.h:567
FlagStatus ADC_DC_ITMaskedStatus(ADC_DC_Module_TypeDef ADC_DC_Module)
Проверка флагов маскированных прерываний.
Definition: niietcm4_adc.c:655
FlagStatus ADC_SEQ_ITRawStatus(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Проверка флагов немаскированных прерываний.
Definition: niietcm4_adc.c:782
void ADC_SEQ_DeInit(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Устанавливает все регистры выбранного секвенсора значениями по умолчанию.
Definition: niietcm4_adc.c:358
void ADC_SEQ_ITCmd(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, FunctionalState State)
Включение прерывания секвенсора.
Definition: niietcm4_adc.c:697
uint32_t ADC_SEQ_GetFIFOLoad(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Получение количества измерений, сохраненных в буфере секвенсора.
Definition: niietcm4_adc.c:916
ADC_Resolution_TypeDef ADC_Resolution
Definition: niietcm4_adc.h:578
void ADC_SEQ_FIFOFullStatusClear(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Cброс флага заполнения буффера секвенсора.
Definition: niietcm4_adc.c:961
uint32_t ADC_SEQ_ConversionDelay
Definition: niietcm4_adc.h:627
void ADC_DC_Cmd(ADC_DC_Module_TypeDef ADC_DC_Module, FunctionalState State)
Включение выходного триггера цифрового компаратора.
#define IS_ADC_DC(DC)
Макрос проверки попадания масок компараторов в допустимый диапазон.
Definition: niietcm4_adc.h:127
#define IS_ADC_MEASURE(MEASURE)
Макрос проверки аргументов типа ADC_Measure_TypeDef.
Definition: niietcm4_adc.h:549
uint32_t ADC_DC_ThresholdLow
Definition: niietcm4_adc.h:601
FlagStatus
Описывает возможные состояния флага при запросе его статуса.
Definition: niietcm4.h:195
#define IS_ADC_MODULE(MODULE)
Макрос проверки аргументов типа ADC_Module_TypeDef.
Definition: niietcm4_adc.h:505
Структура инициализации модулей АЦП
Definition: niietcm4_adc.h:576
FlagStatus ADC_DC_ITRawStatus(ADC_DC_Module_TypeDef ADC_DC_Module)
Проверка флагов немаскированных прерываний.
Definition: niietcm4_adc.c:630
FlagStatus ADC_SEQ_ITMaskedStatus(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Проверка флагов маскированных прерываний.
Definition: niietcm4_adc.c:807
Файл содержит все прототипы функций для работы с АЦП, секвенсорами, цифровыми компараторами.
FunctionalState
Описывает логическое состояние периферии. Используется для операций включения/выключения периферийных...
Definition: niietcm4.h:169
void ADC_StructInit(ADC_Init_TypeDef *ADC_InitStruct)
Заполнение каждого члена структуры ADC_InitStruct значениями по умолчанию.
Definition: niietcm4_adc.c:283
void ADC_SEQ_ITCountRst(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Сброс счетчика прерываний секвенсора.
Definition: niietcm4_adc.c:768
void ADC_DeInit(ADC_Module_TypeDef ADC_Module)
Устанавливает все регистры модуля АЦП значениями по умолчанию.
Definition: niietcm4_adc.c:123
void ADC_DC_ITStatusClear(ADC_DC_Module_TypeDef ADC_DC_Module)
Общий сброс флагов прерывания цифрового компаратора. Сбрасывает как маскированные, так и немаскированные флаги.
Definition: niietcm4_adc.c:681
void ADC_SEQ_DMAConfig(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, ADC_SEQ_FIFOLevel_TypeDef ADC_SEQ_FIFOLevel)
Конфигуририрует выбранный секвенсор для работы с DMA.
Definition: niietcm4_adc.c:472
ADC_Measure_TypeDef ADC_Measure_A
Definition: niietcm4_adc.h:580
uint32_t ADC_DC_ThresholdHigh
Definition: niietcm4_adc.h:603
#define IS_ADC_SEQ_CONVERSION_DELAY(CONVERSION_DELAY)
Проверка значения задержки запуска преобразования модулем АЦП на попадание в допустимый диапазон...
Definition: niietcm4_adc.h:182
ADC_Average_TypeDef ADC_Average
Definition: niietcm4_adc.h:586
void ADC_DC_ITGenCmd(ADC_DC_Module_TypeDef ADC_DC_Module, FunctionalState State)
Разрешает компаратору генерировать сигнал прерывания.
Definition: niietcm4_adc.c:546
Структура инициализации секвенсоров.
Definition: niietcm4_adc.h:617
#define IS_FUNCTIONAL_STATE(STATE)
Макрос проверки аргументов типа FunctionalState.
Definition: niietcm4.h:179
#define IS_ADC_SEQ_CONVERSION_COUNT(CONVERSION_COUNT)
Проверка значения количества перезапусков модулей АЦП секвенсором после запуска секвенсора по событию...
Definition: niietcm4_adc.h:176
void ADC_DC_DeInit(ADC_DC_Module_TypeDef ADC_DC_Module)
Устанавливает все регистры выбранного цифрового компаратора значениями по умолчанию.
Definition: niietcm4_adc.c:300
void ADC_SEQ_Init(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, ADC_SEQ_Init_TypeDef *ADC_SEQ_InitStruct)
Инициализирует выбранный секвенсор согласно параметрам структуры ADC_SEQ_InitStruct.
Definition: niietcm4_adc.c:418
void ADC_DC_StructInit(ADC_DC_Init_TypeDef *ADC_DC_InitStruct)
Заполнение каждого члена структуры ADC_DC_InitStruct значениями по умолчанию.
Definition: niietcm4_adc.c:342
#define IS_ADC_DC_THRESHOLD(THRESHOLD)
Проверка значения порога диапазона срабатывания компаратора на попадание в допустимый диапазон...
Definition: niietcm4_adc.h:195
uint32_t ADC_SEQ_GetITCount(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Текущее значение счетчика измерений, который используется для генерации прерывания секвенсора...
Definition: niietcm4_adc.c:750
ADC_SEQ_FIFOLevel_TypeDef
Количество результатов измерений записанных в буфер секвенсора, по достижению которого вызывается DMA...
Definition: niietcm4_adc.h:370
void ADC_Cmd(ADC_Module_TypeDef ADC_Module, FunctionalState State)
Включение модуля АЦП.
Definition: niietcm4_adc.c:108
#define IS_ADC_RESOLUTION(RESOLUTION)
Макрос проверки аргументов типа ADC_Resolution_TypeDef.
Definition: niietcm4_adc.h:532
Структура инициализации цифровых компараторов.
Definition: niietcm4_adc.h:599
void ADC_DC_ITMaskCmd(ADC_DC_Module_TypeDef ADC_DC_Module, FunctionalState State)
Маскирование сигнала прерывания цифрового компаратора.
Definition: niietcm4_adc.c:563
ADC_DC_Channel_TypeDef ADC_DC_Channel
Definition: niietcm4_adc.h:605
ADC_DC_Mode_TypeDef ADC_DC_Mode
Definition: niietcm4_adc.h:607
ADC_DC_Condition_TypeDef
Условие срабатывания компаратора.
Definition: niietcm4_adc.h:351