NIIETCM4 PD  v0.7.0
Драйвер периферии для микроконтроллеров на базе ядра ARM Cortex-M4
niietcm4_adc.c
См. документацию.
1 
30 /* Includes ------------------------------------------------------------------*/
31 #include "niietcm4_adc.h"
32 
116 {
117  assert_param(IS_ADC_MODULE(ADC_Module));
118  assert_param(IS_FUNCTIONAL_STATE(State));
119 
120  NT_ADC->ADCPP_bit[(uint32_t)ADC_Module].ENA = (uint32_t)State;
121 }
122 
131 {
132  assert_param(IS_ADC_MODULE(ADC_Module));
133 
134  if (ADC_Module == ADC_Module_0)
135  {
136  NT_ADC->ADCSPC0_bit.PHASE0 = 0;
137  NT_ADC->ADCSAC_bit.AVG0 = 0;
138  }
139  else if (ADC_Module == ADC_Module_1)
140  {
141  NT_ADC->ADCSPC0_bit.PHASE1 = 0;
142  NT_ADC->ADCSAC_bit.AVG1 = 0;
143  }
144  else if (ADC_Module == ADC_Module_2)
145  {
146  NT_ADC->ADCSPC1_bit.PHASE2 = 0;
147  NT_ADC->ADCSAC_bit.AVG2 = 0;
148  }
149  else if (ADC_Module == ADC_Module_3)
150  {
151  NT_ADC->ADCSPC1_bit.PHASE3 = 0;
152  NT_ADC->ADCSAC_bit.AVG3 = 0;
153  }
154  else if (ADC_Module == ADC_Module_4)
155  {
156  NT_ADC->ADCSPC2_bit.PHASE4 = 0;
157  NT_ADC->ADCSAC_bit.AVG4 = 0;
158  }
159  else if (ADC_Module == ADC_Module_5)
160  {
161  NT_ADC->ADCSPC2_bit.PHASE5 = 0;
162  NT_ADC->ADCSAC_bit.AVG5 = 0;
163  }
164  else if (ADC_Module == ADC_Module_6)
165  {
166  NT_ADC->ADCSPC3_bit.PHASE6 = 0;
167  NT_ADC->ADCSAC_bit.AVG6 = 0;
168  }
169  else if (ADC_Module == ADC_Module_7)
170  {
171  NT_ADC->ADCSPC3_bit.PHASE7 = 0;
172  NT_ADC->ADCSAC_bit.AVG7 = 0;
173  }
174  else if (ADC_Module == ADC_Module_8)
175  {
176  NT_ADC->ADCSPC4_bit.PHASE8 = 0;
177  NT_ADC->RICNT_bit.AVG8 = 0;
178  }
179  else if (ADC_Module == ADC_Module_9)
180  {
181  NT_ADC->ADCSPC4_bit.PHASE9 = 0;
182  NT_ADC->RICNT_bit.AVG9 = 0;
183  }
184  else if (ADC_Module == ADC_Module_10)
185  {
186  NT_ADC->ADCSPC5_bit.PHASE10 = 0;
187  NT_ADC->RICNT_bit.AVG10 = 0;
188  }
189  else if (ADC_Module == ADC_Module_11)
190  {
191  NT_ADC->ADCSPC5_bit.PHASE11 = 0;
192  NT_ADC->RICNT_bit.AVG11 = 0;
193  }
194 
195  NT_ADC->ADCPP_bit[(uint32_t)ADC_Module].OM = 0;
196 }
197 
206 void ADC_Init(ADC_Module_TypeDef ADC_Module, ADC_Init_TypeDef* ADC_InitStruct)
207 {
208  assert_param(IS_ADC_MODULE(ADC_Module));
209  assert_param(IS_ADC_RESOLUTION(ADC_InitStruct->ADC_Resolution));
210  assert_param(IS_ADC_MEASURE(ADC_InitStruct->ADC_Measure_A));
211  assert_param(IS_ADC_MEASURE(ADC_InitStruct->ADC_Measure_B));
212  assert_param(IS_ADC_PHASE(ADC_InitStruct->ADC_Phase));
213  assert_param(IS_ADC_AVERAGE(ADC_InitStruct->ADC_Average));
214  assert_param(IS_ADC_MODE(ADC_InitStruct->ADC_Mode));
215 
216  if (ADC_Module == ADC_Module_0)
217  {
218  NT_ADC->ADCSPC0_bit.PHASE0 = ADC_InitStruct->ADC_Phase;
219  NT_ADC->ADCSAC_bit.AVG0 = ADC_InitStruct->ADC_Average;
220  }
221  else if (ADC_Module == ADC_Module_1)
222  {
223  NT_ADC->ADCSPC0_bit.PHASE1 = ADC_InitStruct->ADC_Phase;
224  NT_ADC->ADCSAC_bit.AVG1 = ADC_InitStruct->ADC_Average;
225  }
226  else if (ADC_Module == ADC_Module_2)
227  {
228  NT_ADC->ADCSPC1_bit.PHASE2 = ADC_InitStruct->ADC_Phase;
229  NT_ADC->ADCSAC_bit.AVG2 = ADC_InitStruct->ADC_Average;
230  }
231  else if (ADC_Module == ADC_Module_3)
232  {
233  NT_ADC->ADCSPC1_bit.PHASE3 = ADC_InitStruct->ADC_Phase;
234  NT_ADC->ADCSAC_bit.AVG3 = ADC_InitStruct->ADC_Average;
235  }
236  else if (ADC_Module == ADC_Module_4)
237  {
238  NT_ADC->ADCSPC2_bit.PHASE4 = ADC_InitStruct->ADC_Phase;
239  NT_ADC->ADCSAC_bit.AVG4 = ADC_InitStruct->ADC_Average;
240  }
241  else if (ADC_Module == ADC_Module_5)
242  {
243  NT_ADC->ADCSPC2_bit.PHASE5 = ADC_InitStruct->ADC_Phase;
244  NT_ADC->ADCSAC_bit.AVG5 = ADC_InitStruct->ADC_Average;
245  }
246  else if (ADC_Module == ADC_Module_6)
247  {
248  NT_ADC->ADCSPC3_bit.PHASE6 = ADC_InitStruct->ADC_Phase;
249  NT_ADC->ADCSAC_bit.AVG6 = ADC_InitStruct->ADC_Average;
250  }
251  else if (ADC_Module == ADC_Module_7)
252  {
253  NT_ADC->ADCSPC3_bit.PHASE7 = ADC_InitStruct->ADC_Phase;
254  NT_ADC->ADCSAC_bit.AVG7 = ADC_InitStruct->ADC_Average;
255  }
256  else if (ADC_Module == ADC_Module_8)
257  {
258  NT_ADC->ADCSPC4_bit.PHASE8 = ADC_InitStruct->ADC_Phase;
259  NT_ADC->RICNT_bit.AVG8 = ADC_InitStruct->ADC_Average;
260  }
261  else if (ADC_Module == ADC_Module_9)
262  {
263  NT_ADC->ADCSPC4_bit.PHASE9 = ADC_InitStruct->ADC_Phase;
264  NT_ADC->RICNT_bit.AVG9 = ADC_InitStruct->ADC_Average;
265  }
266  else if (ADC_Module == ADC_Module_10)
267  {
268  NT_ADC->ADCSPC5_bit.PHASE10 = ADC_InitStruct->ADC_Phase;
269  NT_ADC->RICNT_bit.AVG10 = ADC_InitStruct->ADC_Average;
270  }
271  else if (ADC_Module == ADC_Module_11)
272  {
273  NT_ADC->ADCSPC5_bit.PHASE11 = ADC_InitStruct->ADC_Phase;
274  NT_ADC->RICNT_bit.AVG11 = ADC_InitStruct->ADC_Average;
275  }
276 
277  NT_ADC->ADCPP_bit[(uint32_t)ADC_Module].OM = (((uint32_t)ADC_InitStruct->ADC_Measure_B)<<6) |
278  (((uint32_t)ADC_InitStruct->ADC_Measure_A)<<4) |
279  (((uint32_t)ADC_InitStruct->ADC_Resolution)<<3) |
280  (((uint32_t)ADC_InitStruct->ADC_Mode)<<0);
281 }
282 
290 void ADC_StructInit(ADC_Init_TypeDef* ADC_InitStruct)
291 {
292  ADC_InitStruct->ADC_Resolution = ADC_Resolution_12bit;
293  ADC_InitStruct->ADC_Measure_A = ADC_Measure_Single;
294  ADC_InitStruct->ADC_Measure_B = ADC_Measure_Single;
295  ADC_InitStruct->ADC_Phase = 0;
296  ADC_InitStruct->ADC_Average = ADC_Average_Disable;
297  ADC_InitStruct->ADC_Mode = ADC_Mode_Powerdown;
298 }
299 
308 {
309  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
310 
311  NT_ADC->ADCDCCMP_bit[(uint32_t)ADC_DC_Module].COMP0 = 0;
312  NT_ADC->ADCDCCMP_bit[(uint32_t)ADC_DC_Module].COMP1 = 0;
313  NT_ADC->ADCDCCTL_bit[(uint32_t)ADC_DC_Module].CHNL = 0x1F; // т.к. 0 = выбран нулевой канал, то нужно перевести в запрещенное состояние
314  NT_ADC->ADCDCCTL_bit[(uint32_t)ADC_DC_Module].CTC = 0;
315  NT_ADC->ADCDCCTL_bit[(uint32_t)ADC_DC_Module].CTM = 0;
316 }
317 
326 void ADC_DC_Init(ADC_DC_Module_TypeDef ADC_DC_Module, ADC_DC_Init_TypeDef* ADC_DC_InitStruct)
327 {
328  assert_param(IS_ADC_DC(ADC_DC_Module));
329  assert_param(IS_ADC_DC_THRESHOLD(ADC_DC_InitStruct->ADC_DC_ThresholdLow));
330  assert_param(IS_ADC_DC_THRESHOLD(ADC_DC_InitStruct->ADC_DC_ThresholdHigh));
331  assert_param(IS_ADC_DC_CHANNEL(ADC_DC_InitStruct->ADC_DC_Channel));
332  assert_param(IS_ADC_DC_MODE(ADC_DC_InitStruct->ADC_DC_Mode));
333  assert_param(IS_ADC_DC_CONDITION(ADC_DC_InitStruct->ADC_DC_Condition));
334 
335  NT_ADC->ADCDCCMP_bit[(uint32_t)ADC_DC_Module].COMP0 = ADC_DC_InitStruct->ADC_DC_ThresholdLow;
336  NT_ADC->ADCDCCMP_bit[(uint32_t)ADC_DC_Module].COMP1 = ADC_DC_InitStruct->ADC_DC_ThresholdHigh;
337  NT_ADC->ADCDCCTL_bit[(uint32_t)ADC_DC_Module].CHNL = (uint32_t)ADC_DC_InitStruct->ADC_DC_Channel;
338  NT_ADC->ADCDCCTL_bit[(uint32_t)ADC_DC_Module].CTC = (uint32_t)ADC_DC_InitStruct->ADC_DC_Condition;
339  NT_ADC->ADCDCCTL_bit[(uint32_t)ADC_DC_Module].CTM = (uint32_t)ADC_DC_InitStruct->ADC_DC_Mode;
340 }
341 
349 void ADC_DC_StructInit(ADC_DC_Init_TypeDef* ADC_DC_InitStruct)
350 {
351  ADC_DC_InitStruct->ADC_DC_ThresholdLow = 0;
352  ADC_DC_InitStruct->ADC_DC_ThresholdHigh = 0;
353  ADC_DC_InitStruct->ADC_DC_Channel = ADC_DC_Channel_None;
354  ADC_DC_InitStruct->ADC_DC_Mode = ADC_DC_Mode_Single;
355  ADC_DC_InitStruct->ADC_DC_Condition = ADC_DC_Condition_Low;
356 }
357 
366 {
367  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
368 
369  if (ADC_SEQ_Module == ADC_SEQ_Module_0)
370  {
371  NT_ADC->ADCEMUX_bit.EM0 = 0;
372  NT_ADC->ADCPSSI_bit.SS0 = 0;
373  }
374  else if (ADC_SEQ_Module == ADC_SEQ_Module_1)
375  {
376  NT_ADC->ADCEMUX_bit.EM1 = 0;
377  NT_ADC->ADCPSSI_bit.SS1 = 0;
378  }
379  else if (ADC_SEQ_Module == ADC_SEQ_Module_2)
380  {
381  NT_ADC->ADCEMUX_bit.EM2 = 0;
382  NT_ADC->ADCPSSI_bit.SS2 = 0;
383  }
384  else if (ADC_SEQ_Module == ADC_SEQ_Module_3)
385  {
386  NT_ADC->ADCEMUX_bit.EM3 = 0;
387  NT_ADC->ADCPSSI_bit.SS3 = 0;
388  }
389  else if (ADC_SEQ_Module == ADC_SEQ_Module_4)
390  {
391  NT_ADC->ADCEMUX_bit.EM4 = 0;
392  NT_ADC->ADCPSSI_bit.SS4 = 0;
393  }
394  else if (ADC_SEQ_Module == ADC_SEQ_Module_5)
395  {
396  NT_ADC->ADCEMUX_bit.EM5 = 0;
397  NT_ADC->ADCPSSI_bit.SS5 = 0;
398  }
399  else if (ADC_SEQ_Module == ADC_SEQ_Module_6)
400  {
401  NT_ADC->ADCEMUX_bit.EM6 = 0;
402  NT_ADC->ADCPSSI_bit.SS6 = 0;
403  }
404  else if (ADC_SEQ_Module == ADC_SEQ_Module_7)
405  {
406  NT_ADC->ADCEMUX_bit.EM7 = 0;
407  NT_ADC->ADCPSSI_bit.SS7 = 0;
408  }
409 
410  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSCTL_bit.RCNT = 0;
411  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSTMR_bit.TMR = 2;
412  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSDCP = 0;
413  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSMUX = 0;
414 }
415 
425 void ADC_SEQ_Init(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, ADC_SEQ_Init_TypeDef* ADC_SEQ_InitStruct)
426 {
427  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
428  assert_param(IS_ADC_SEQ_START_EVENT(ADC_SEQ_InitStruct->ADC_SEQ_StartEvent));
429  assert_param(IS_FUNCTIONAL_STATE(ADC_SEQ_InitStruct->ADC_SEQ_SWReqEn));
430  assert_param(IS_ADC_CHANNEL(ADC_SEQ_InitStruct->ADC_Channels));
431  assert_param(IS_ADC_SEQ_CONVERSION_COUNT(ADC_SEQ_InitStruct->ADC_SEQ_ConversionCount));
432  assert_param(IS_ADC_SEQ_CONVERSION_DELAY(ADC_SEQ_InitStruct->ADC_SEQ_ConversionDelay));
433  assert_param(IS_ADC_DC(ADC_SEQ_InitStruct->ADC_SEQ_DC));
434 
435  NT_ADC->ADCEMUX &= ~(0xF<<((uint32_t)ADC_SEQ_Module*4));
436  NT_ADC->ADCEMUX |= ((uint32_t)ADC_SEQ_InitStruct->ADC_SEQ_StartEvent)<<((uint32_t)ADC_SEQ_Module*4);
437 
438  if (ADC_SEQ_InitStruct->ADC_SEQ_SWReqEn == ENABLE)
439  {
440  NT_ADC->ADCPSSI |= 1<<((uint32_t)ADC_SEQ_Module);
441  }
442  else
443  {
444  NT_ADC->ADCPSSI &= ~(1<<((uint32_t)ADC_SEQ_Module));
445  }
446 
447  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSCTL_bit.RCNT = (uint32_t)(ADC_SEQ_InitStruct->ADC_SEQ_ConversionCount-1);
448  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSTMR_bit.TMR = (uint32_t)ADC_SEQ_InitStruct->ADC_SEQ_ConversionDelay;
449  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSDCP = (uint32_t)ADC_SEQ_InitStruct->ADC_SEQ_DC;
450  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSMUX = (uint32_t)ADC_SEQ_InitStruct->ADC_Channels;
451 }
452 
460 void ADC_SEQ_StructInit(ADC_SEQ_Init_TypeDef* ADC_SEQ_InitStruct)
461 {
462  ADC_SEQ_InitStruct->ADC_SEQ_StartEvent = ADC_SEQ_StartEvent_SWReq;
463  ADC_SEQ_InitStruct->ADC_SEQ_SWReqEn = ENABLE;
464  ADC_SEQ_InitStruct->ADC_Channels = ADC_Channel_None;
465  ADC_SEQ_InitStruct->ADC_SEQ_ConversionCount = 1;
466  ADC_SEQ_InitStruct->ADC_SEQ_ConversionDelay = 2;
467  ADC_SEQ_InitStruct->ADC_SEQ_DC = ADC_DC_None;
468 }
469 
480 {
481  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
482  assert_param(IS_ADC_SEQ_FIFO_LEVEL(ADC_SEQ_FIFOLevel));
483 
484  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSCTL_bit.WMARK = (uint32_t)ADC_SEQ_FIFOLevel;
485 }
486 
497 {
498  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
499  assert_param(IS_FUNCTIONAL_STATE(State));
500 
501  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSCTL_bit.DMAEN = (uint32_t)State;
502 }
503 
513 {
514  FlagStatus Status;
515 
516  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
517 
518  if (NT_ADC->ADCOSTAT & (1<<((uint32_t)ADC_SEQ_Module + 16))) // в первых 16 - флаги заполнения буфера секвенсора
519  {
520  Status = Flag_SET;
521  }
522  else
523  {
524  Status = Flag_CLEAR;
525  }
526 
527  return Status;
528 }
529 
538 {
539  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
540 
541  NT_ADC->ADCOSTAT = 1<<((uint32_t)ADC_SEQ_Module + 16);
542 }
543 
554 {
555  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
556  assert_param(IS_FUNCTIONAL_STATE(State));
557 
558  NT_ADC->ADCDCCTL_bit[(uint32_t)ADC_DC_Module].CIE = (uint32_t)State;
559 }
560 
571 {
572  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
573  assert_param(IS_FUNCTIONAL_STATE(State));
574 
575  if (State == ENABLE)
576  {
577  NT_ADC->ADCIM |= 1<<((uint32_t)ADC_DC_Module + 8); // первые 8 - это секвенсоры
578  }
579  else /* if (State == DISABLE) */
580  {
581  NT_ADC->ADCIM &= ~(1<<((uint32_t)ADC_DC_Module + 8)); // первые 8 - это секвенсоры
582  }
583 }
584 
597 {
598  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
599  assert_param(IS_FUNCTIONAL_STATE(State));
600 
601  //разрешение/запрещение генерации сигнала прерывания компаратору
602  ADC_DC_ITGenCmd(ADC_DC_Module, State);
603 
604  //маскирование сигнала прерывания для попадания внутрь NVIC
605  ADC_DC_ITMaskCmd(ADC_DC_Module, State);
606 }
607 
620 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)
621 {
622  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
623  assert_param(IS_ADC_DC_MODE(ADC_DC_Mode));
624  assert_param(IS_ADC_DC_CONDITION(ADC_DC_Condition));
625 
626  NT_ADC->ADCDCCTL_bit[(uint32_t)ADC_DC_Module].CIC = (uint32_t)ADC_DC_Condition;
627  NT_ADC->ADCDCCTL_bit[(uint32_t)ADC_DC_Module].CIM = (uint32_t)ADC_DC_Mode;
628 }
629 
638 {
639  FlagStatus Status;
640 
641  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
642 
643  if (NT_ADC->ADCRIS & (1<<((uint32_t)ADC_DC_Module + 8)))
644  {
645  Status = Flag_SET;
646  }
647  else
648  {
649  Status = Flag_CLEAR;
650  }
651 
652  return Status;
653 }
654 
663 {
664  FlagStatus Status;
665 
666  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
667 
668  if (NT_ADC->ADCISC & (1<<((uint32_t)ADC_DC_Module + 8)))
669  {
670  Status = Flag_SET;
671  }
672  else
673  {
674  Status = Flag_CLEAR;
675  }
676 
677  return Status;
678 }
679 
689 {
690  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
691 
692  NT_ADC->ADCISC = 1<<((uint32_t)ADC_DC_Module + 8); // первые 8 - это секвенсоры
693 }
694 
705 {
706  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
707  assert_param(IS_FUNCTIONAL_STATE(State));
708 
709  if (State == ENABLE)
710  {
711  NT_ADC->ADCIM |= 1<<((uint32_t)ADC_SEQ_Module); // первые 8 - это секвенсоры
712  }
713  else /* if (State == DISABLE) */
714  {
715  NT_ADC->ADCIM &= ~(1<<((uint32_t)ADC_SEQ_Module)); // первые 8 - это секвенсоры
716  }
717 }
718 
732 void ADC_SEQ_ITConfig(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, uint32_t ADC_SEQ_ITRate, FunctionalState ADC_SEQ_ITCountSEQRst)
733 {
734  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
735  assert_param(IS_ADC_SEQ_IT_RATE(ADC_SEQ_ITRate));
736  assert_param(IS_FUNCTIONAL_STATE(ADC_SEQ_ITCountSEQRst));
737 
738  if (ADC_SEQ_ITCountSEQRst == ENABLE)
739  {
740  NT_ADC->RICNT |= 1<<((uint32_t)ADC_SEQ_Module + 16); // первые 16 - это усреднители 8-11
741  }
742  else /* if (State == DISABLE) */
743  {
744  NT_ADC->RICNT &= ~(1<<((uint32_t)ADC_SEQ_Module + 16)); // первые 16 - это усреднители 8-11
745  }
746 
747  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSCTL_bit.ICNT = ADC_SEQ_ITRate - 1;
748 }
749 
758 {
759  uint32_t ITCount;
760 
761  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
762 
763  ITCount = NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSOP_bit.ICNT;
764 
765  return ITCount;
766 }
767 
776 {
777  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
778 
779  NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSOP_bit.ICNT = 1;
780 }
781 
790 {
791  FlagStatus Status;
792 
793  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
794 
795  if (NT_ADC->ADCRIS & (1<<((uint32_t)ADC_SEQ_Module)))
796  {
797  Status = Flag_SET;
798  }
799  else
800  {
801  Status = Flag_CLEAR;
802  }
803 
804  return Status;
805 }
806 
815 {
816  FlagStatus Status;
817 
818  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
819 
820  if (NT_ADC->ADCISC & (1<<((uint32_t)ADC_SEQ_Module)))
821  {
822  Status = Flag_SET;
823  }
824  else
825  {
826  Status = Flag_CLEAR;
827  }
828 
829  return Status;
830 }
831 
840 {
841  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
842 
843  NT_ADC->ADCISC = 1<<((uint32_t)ADC_SEQ_Module);
844 }
845 
856 {
857  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
858  assert_param(IS_FUNCTIONAL_STATE(State));
859 
860  if (State == ENABLE)
861  {
862  NT_ADC->ADCACTSS |= 1<<((uint32_t)ADC_SEQ_Module);
863  }
864  else /* if (State == DISABLE) */
865  {
866  NT_ADC->ADCACTSS &= ~(1<<((uint32_t)ADC_SEQ_Module));
867  }
868 }
869 
876 {
877  NT_ADC->ADCPSSI_bit.GSYNC = 1;
878 }
879 
888 {
889  uint32_t Data;
890 
891  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
892 
893  Data = NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].FIFO_bit.DATA;
894 
895  return Data;
896 }
897 
906 {
907  uint32_t Count;
908 
909  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
910 
911  Count = NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSOP_bit.RCNT;
912 
913  return Count;
914 }
915 
924 {
925  uint32_t Load;
926 
927  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
928 
929  Load = NT_ADC->ADSSEQ[(uint32_t)ADC_SEQ_Module].ADCSSFSTAT_bit.FLOAD;
930 
931  return Load;
932 }
933 
944 {
945  FlagStatus Status;
946 
947  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
948 
949  if (NT_ADC->ADCOSTAT & (1<<((uint32_t)ADC_SEQ_Module)))
950  {
951  Status = Flag_SET;
952  }
953  else
954  {
955  Status = Flag_CLEAR;
956  }
957 
958  return Status;
959 }
960 
969 {
970  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
971 
972  NT_ADC->ADCOSTAT = 1<<((uint32_t)ADC_SEQ_Module);
973 }
974 
984 {
985  FlagStatus Status;
986 
987  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
988 
989  if (NT_ADC->ADCUSTAT & (1<<((uint32_t)ADC_SEQ_Module)))
990  {
991  Status = Flag_SET;
992  }
993  else
994  {
995  Status = Flag_CLEAR;
996  }
997 
998  return Status;
999 }
1000 
1009 {
1010  assert_param(IS_ADC_SEQ_MODULE(ADC_SEQ_Module));
1011 
1012  NT_ADC->ADCUSTAT = 1<<((uint32_t)ADC_SEQ_Module);
1013 }
1014 
1025 {
1026  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
1027  assert_param(IS_FUNCTIONAL_STATE(State));
1028 
1029  NT_ADC->ADCDCCTL_bit[(uint32_t)ADC_DC_Module].CTE = (uint32_t)State;
1030 }
1031 
1041 {
1042  uint32_t Value;
1043 
1044  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
1045 
1046  Value = NT_ADC->ADCDCVAL_bit[(uint32_t)ADC_DC_Module].VAL;
1047 
1048  return Value;
1049 }
1050 
1059 {
1060  FlagStatus Status;
1061 
1062  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
1063 
1064  if (NT_ADC->ADCDCRIC_H & (1<<((uint32_t)ADC_DC_Module)))
1065  {
1066  Status = Flag_SET;
1067  }
1068  else
1069  {
1070  Status = Flag_CLEAR;
1071  }
1072 
1073  return Status;
1074 }
1075 
1087 {
1088  assert_param(IS_ADC_DC_MODULE(ADC_DC_Module));
1089 
1090  // чтобы сбросить 0 и 1 компараторы, нужно писать в биты 10 и 11 компараторов соответственно
1091  if ((ADC_DC_Module == ADC_DC_Module_0) |
1092  (ADC_DC_Module == ADC_DC_Module_1))
1093  {
1094  ADC_DC_Module = (ADC_DC_Module_TypeDef)((uint32_t)ADC_DC_Module + 10);
1095  }
1096 
1097  NT_ADC->ADCDCRIC_H = 1<<((uint32_t)ADC_DC_Module + 8);
1098 }
1099 
1116 /******************* (C) COPYRIGHT 2015 NIIET *****END OF FILE****/
void ADC_SEQ_ITCmd(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, FunctionalState State)
Включение прерывания секвенсора.
Definition: niietcm4_adc.c:704
ADC_DC_Condition_TypeDef ADC_DC_Condition
Definition: niietcm4_adc.h:609
void ADC_Cmd(ADC_Module_TypeDef ADC_Module, FunctionalState State)
Включение модуля АЦП.
Definition: niietcm4_adc.c:115
void ADC_DC_TrigStatusClear(ADC_DC_Module_TypeDef ADC_DC_Module)
Cброс выходного триггера цифрового компаратора.
ADC_DC_Mode_TypeDef
Режим срабатывания компаратора.
Definition: niietcm4_adc.h:330
void ADC_DC_ITGenCmd(ADC_DC_Module_TypeDef ADC_DC_Module, FunctionalState State)
Разрешает компаратору генерировать сигнал прерывания.
Definition: niietcm4_adc.c:553
#define IS_ADC_DC_CHANNEL(CHANNEL)
Макрос проверки аргументов типа ADC_DC_Channel_TypeDef.
Definition: niietcm4_adc.h:300
void ADC_SEQ_Cmd(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, FunctionalState State)
Включение секвенсора.
Definition: niietcm4_adc.c:855
void ADC_SEQ_DMAErrorStatusClear(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Сброс статуса ошибки DMA.
Definition: niietcm4_adc.c:537
void ADC_DC_StructInit(ADC_DC_Init_TypeDef *ADC_DC_InitStruct)
Заполнение каждого члена структуры ADC_DC_InitStruct значениями по умолчанию.
Definition: niietcm4_adc.c:349
FunctionalState ADC_SEQ_SWReqEn
Definition: niietcm4_adc.h:621
ADC_SEQ_Module_TypeDef
Выбор модуля секвенсора.
Definition: niietcm4_adc.h:456
#define IS_ADC_SEQ_CONVERSION_DELAY(CONVERSION_DELAY)
Проверка значения задержки запуска преобразования модулем АЦП на попадание в допустимый диапазон...
Definition: niietcm4_adc.h:182
void ADC_SEQ_DMACmd(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, FunctionalState State)
Включает для выбранного секвенсора генерирование запросов DMA.
Definition: niietcm4_adc.c:496
#define IS_ADC_DC_CONDITION(CONDITION)
Макрос проверки аргументов типа ADC_DC_Condition_TypeDef.
Definition: niietcm4_adc.h:362
void ADC_DC_ITStatusClear(ADC_DC_Module_TypeDef ADC_DC_Module)
Общий сброс флагов прерывания цифрового компаратора. Сбрасывает как маскированные, так и немаскированные флаги.
Definition: niietcm4_adc.c:688
void ADC_DC_ITCmd(ADC_DC_Module_TypeDef ADC_DC_Module, FunctionalState State)
Включение прерывания компаратора и одновременное маскирование сигнала этого прерывания. При этом, эти же действия можно выполнить путем ручного вызовова соответствующих функций: ADC_DC_ITGenCmd и ADC_DC_ITMaskCmd.
Definition: niietcm4_adc.c:596
FunctionalState
Описывает логическое состояние периферии. Используется для операций включения/выключения периферийных...
Definition: niietcm4.h:157
ADC_SEQ_StartEvent_TypeDef ADC_SEQ_StartEvent
Definition: niietcm4_adc.h:619
void ADC_StructInit(ADC_Init_TypeDef *ADC_InitStruct)
Заполнение каждого члена структуры ADC_InitStruct значениями по умолчанию.
Definition: niietcm4_adc.c:290
#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
void ADC_SEQ_ITConfig(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, uint32_t ADC_SEQ_ITRate, FunctionalState ADC_SEQ_ITCountSEQRst)
Настройка вызова прерывания секвенсора.
Definition: niietcm4_adc.c:732
void ADC_DC_DeInit(ADC_DC_Module_TypeDef ADC_DC_Module)
Устанавливает все регистры выбранного цифрового компаратора значениями по умолчанию.
Definition: niietcm4_adc.c:307
#define IS_ADC_SEQ_IT_RATE(IT_RATE)
Проверка значения количества перезапусков модулей АЦП секвенсором после которого генерируется прерыва...
Definition: niietcm4_adc.h:169
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:326
#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
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
void ADC_SEQ_SWReq()
Программный запуск измерений всех разрешенных секвенсоров.
Definition: niietcm4_adc.c:875
void ADC_SEQ_ITStatusClear(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Общий сброс флагов прерывания секвенсора. Сбрасывает как маскированные, так и немаскированные флаги...
Definition: niietcm4_adc.c:839
#define IS_ADC_DC(DC)
Макрос проверки попадания масок компараторов в допустимый диапазон.
Definition: niietcm4_adc.h:127
ADC_Measure_TypeDef ADC_Measure_B
Definition: niietcm4_adc.h:582
FlagStatus
Описывает возможные состояния флага при запросе его статуса.
Definition: niietcm4.h:183
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:425
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:620
uint32_t ADC_Phase
Definition: niietcm4_adc.h:584
uint32_t ADC_SEQ_GetITCount(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Текущее значение счетчика измерений, который используется для генерации прерывания секвенсора...
Definition: niietcm4_adc.c:757
#define ADC_Channel_None
Definition: niietcm4_adc.h:56
void ADC_SEQ_FIFOEmptyStatusClear(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Cброс флага пустоты буффера секвенсора.
#define ADC_DC_None
Definition: niietcm4_adc.h:96
ADC_Module_TypeDef
Выбор модуля АЦП.
Definition: niietcm4_adc.h:485
uint32_t ADC_SEQ_GetFIFOLoad(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Получение количества измерений, сохраненных в буфере секвенсора.
Definition: niietcm4_adc.c:923
#define IS_ADC_DC_MODE(MODE)
Макрос проверки аргументов типа ADC_DC_Mode_TypeDef.
Definition: niietcm4_adc.h:342
#define IS_ADC_SEQ_CONVERSION_COUNT(CONVERSION_COUNT)
Проверка значения количества перезапусков модулей АЦП секвенсором после запуска секвенсора по событию...
Definition: niietcm4_adc.h:176
void ADC_DC_ITMaskCmd(ADC_DC_Module_TypeDef ADC_DC_Module, FunctionalState State)
Маскирование сигнала прерывания цифрового компаратора.
Definition: niietcm4_adc.c:570
#define IS_ADC_PHASE(PHASE)
Проверка значения задержки начала преобразования модулем АЦП после запуска модуля секвенсором на попа...
Definition: niietcm4_adc.h:189
#define IS_ADC_MODE(MODE)
Макрос проверки аргументов типа ADC_Mode_TypeDef.
Definition: niietcm4_adc.h:567
FlagStatus ADC_DC_ITRawStatus(ADC_DC_Module_TypeDef ADC_DC_Module)
Проверка флагов немаскированных прерываний.
Definition: niietcm4_adc.c:637
ADC_Resolution_TypeDef ADC_Resolution
Definition: niietcm4_adc.h:578
uint32_t ADC_SEQ_GetConversionCount(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Получение количества измерений, проведенных модулями АЦП с момента запуска секвенсора.
Definition: niietcm4_adc.c:905
FlagStatus ADC_DC_ITMaskedStatus(ADC_DC_Module_TypeDef ADC_DC_Module)
Проверка флагов маскированных прерываний.
Definition: niietcm4_adc.c:662
uint32_t ADC_SEQ_ConversionDelay
Definition: niietcm4_adc.h:627
void ADC_SEQ_DeInit(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Устанавливает все регистры выбранного секвенсора значениями по умолчанию.
Definition: niietcm4_adc.c:365
FlagStatus ADC_SEQ_DMAErrorStatus(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Проверка статуса ошибки, когда при наличии двух обрабатываемых запросов DMA от выбранного секвенсора...
Definition: niietcm4_adc.c:512
#define IS_ADC_MEASURE(MEASURE)
Макрос проверки аргументов типа ADC_Measure_TypeDef.
Definition: niietcm4_adc.h:549
uint32_t ADC_DC_ThresholdLow
Definition: niietcm4_adc.h:601
uint32_t ADC_DC_GetLastData(ADC_DC_Module_TypeDef ADC_DC_Module)
Значение результата измерения, которое последним использовалось компаратором при проверке на соответс...
#define IS_ADC_MODULE(MODULE)
Макрос проверки аргументов типа ADC_Module_TypeDef.
Definition: niietcm4_adc.h:505
Структура инициализации модулей АЦП
Definition: niietcm4_adc.h:576
FlagStatus ADC_SEQ_FIFOEmptyStatus(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Проверка флага пустоты буффера секвенсора. Флаг установлен когда буфер полностью пуст.
Definition: niietcm4_adc.c:983
#define IS_ADC_DC_THRESHOLD(THRESHOLD)
Проверка значения порога диапазона срабатывания компаратора на попадание в допустимый диапазон...
Definition: niietcm4_adc.h:195
FlagStatus ADC_SEQ_ITMaskedStatus(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Проверка флагов маскированных прерываний.
Definition: niietcm4_adc.c:814
Файл содержит все прототипы функций для работы с АЦП, секвенсорами, цифровыми компараторами.
FlagStatus ADC_SEQ_ITRawStatus(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Проверка флагов немаскированных прерываний.
Definition: niietcm4_adc.c:789
ADC_Measure_TypeDef ADC_Measure_A
Definition: niietcm4_adc.h:580
uint32_t ADC_DC_ThresholdHigh
Definition: niietcm4_adc.h:603
ADC_Average_TypeDef ADC_Average
Definition: niietcm4_adc.h:586
#define IS_FUNCTIONAL_STATE(STATE)
Макрос проверки аргументов типа FunctionalState.
Definition: niietcm4.h:167
Структура инициализации секвенсоров.
Definition: niietcm4_adc.h:617
void ADC_DeInit(ADC_Module_TypeDef ADC_Module)
Устанавливает все регистры модуля АЦП значениями по умолчанию.
Definition: niietcm4_adc.c:130
void ADC_Init(ADC_Module_TypeDef ADC_Module, ADC_Init_TypeDef *ADC_InitStruct)
Инициализирует выбранный модуль АЦП согласно параметрам структуры ADC_InitStruct. ...
Definition: niietcm4_adc.c:206
ADC_SEQ_FIFOLevel_TypeDef
Количество результатов измерений записанных в буфер секвенсора, по достижению которого вызывается DMA...
Definition: niietcm4_adc.h:370
#define IS_ADC_CHANNEL(CHANNEL)
Макрос проверки попадания масок каналов в допустимый диапазон.
Definition: niietcm4_adc.h:86
FlagStatus ADC_SEQ_FIFOFullStatus(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Проверка флага заполнения буффера секвенсора. Если флаг установлен, то значит что буффер заполнен и в...
Definition: niietcm4_adc.c:943
void ADC_SEQ_ITCountRst(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Сброс счетчика прерываний секвенсора.
Definition: niietcm4_adc.c:775
FlagStatus ADC_DC_TrigStatus(ADC_DC_Module_TypeDef ADC_DC_Module)
Проверка состояния выходного триггера компаратора.
void ADC_SEQ_DMAConfig(ADC_SEQ_Module_TypeDef ADC_SEQ_Module, ADC_SEQ_FIFOLevel_TypeDef ADC_SEQ_FIFOLevel)
Конфигуририрует выбранный секвенсор для работы с DMA.
Definition: niietcm4_adc.c:479
void ADC_DC_Cmd(ADC_DC_Module_TypeDef ADC_DC_Module, FunctionalState State)
Включение выходного триггера цифрового компаратора.
void ADC_SEQ_StructInit(ADC_SEQ_Init_TypeDef *ADC_SEQ_InitStruct)
Заполнение каждого члена структуры ADC_SEQ_InitStruct значениями по умолчанию.
Definition: niietcm4_adc.c:460
#define IS_ADC_RESOLUTION(RESOLUTION)
Макрос проверки аргументов типа ADC_Resolution_TypeDef.
Definition: niietcm4_adc.h:532
Структура инициализации цифровых компараторов.
Definition: niietcm4_adc.h:599
ADC_DC_Channel_TypeDef ADC_DC_Channel
Definition: niietcm4_adc.h:605
uint32_t ADC_SEQ_GetFIFOData(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Получение результата измерений из буффера секвенсора.
Definition: niietcm4_adc.c:887
ADC_DC_Mode_TypeDef ADC_DC_Mode
Definition: niietcm4_adc.h:607
void ADC_SEQ_FIFOFullStatusClear(ADC_SEQ_Module_TypeDef ADC_SEQ_Module)
Cброс флага заполнения буффера секвенсора.
Definition: niietcm4_adc.c:968
ADC_DC_Condition_TypeDef
Условие срабатывания компаратора.
Definition: niietcm4_adc.h:351