cmp_driver.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014 - 2016, Freescale Semiconductor, Inc.
3  * Copyright 2016 NXP
4  * All rights reserved.
5  *
6  * THIS SOFTWARE IS PROVIDED BY NXP "AS IS" AND ANY EXPRESSED OR
7  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
8  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
9  * IN NO EVENT SHALL NXP OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
10  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
11  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
12  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
13  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
14  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
15  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
16  * THE POSSIBILITY OF SUCH DAMAGE.
17  */
53 #include "cmp_driver.h"
54 #include "cmp_hw_access.h"
55 #include <stddef.h>
56 
57 /*******************************************************************************
58  * Variables
59  ******************************************************************************/
60 /* Table of base addresses for CMP instances. */
61 static CMP_Type * const g_cmpBase[] = CMP_BASE_PTRS;
62 /*FUNCTION**********************************************************************
63  *
64  * Function Name : CMP_DRV_Reset
65  * Description : This function set all CMP registers to reset values.
66  *
67  * Implements : CMP_DRV_Reset_Activity
68  *END**************************************************************************/
69 status_t CMP_DRV_Reset(const uint32_t instance)
70 {
71  status_t status = STATUS_SUCCESS;
72  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
73  CMP_Type* baseAddr = g_cmpBase[instance];
74  baseAddr->C0 = C0_RESET_VALUE;
75  baseAddr->C1 = C1_RESET_VALUE;
76  baseAddr->C2 = C1_RESET_VALUE;
77  return status;
78 }
79 
80 /*FUNCTION**********************************************************************
81  *
82  * Function Name : CMP_DRV_GetInitConfigAll
83  * Description : Return a configuration structure with reset values for all components
84  * from comparator module.
85  * Implements : CMP_DRV_GetInitConfigAll_Activity
86  *
87  *END**************************************************************************/
89 {
90  status_t status = STATUS_SUCCESS;
91  DEV_ASSERT(config != NULL);
92  (config->comparator).dmaTriggerState = false;
93  (config->comparator).outputInterruptTrigger = CMP_NO_EVENT;
94  (config->comparator).mode = CMP_DISABLED;
95  (config->comparator).filterSampleCount = 0U;
96  (config->comparator).filterSamplePeriod = 0U;
97  (config->comparator).powerMode = CMP_LOW_SPEED;
98  (config->comparator).inverterState = CMP_NORMAL;
99  (config->comparator).outputSelect = CMP_COUT;
100  (config->comparator).pinState = CMP_UNAVAILABLE;
101  (config->comparator).hysteresisLevel = CMP_LEVEL_HYS_0;
102  (config->dac).state = false;
103  (config->dac).voltageReferenceSource = CMP_VIN1;
104  (config->dac).voltage = 0U;
105  (config->mux).negativeInputMux = 0U;
106  (config->mux).positiveInputMux = 0U;
107  (config->mux).negativePortMux = CMP_DAC;
108  (config->mux).positivePortMux = CMP_DAC;
109  (config->triggerMode).roundRobinState = false;
110  (config->triggerMode).roundRobinInterruptState = false;
111  (config->triggerMode).fixedPort = CMP_PLUS_FIXED;
112  (config->triggerMode).fixedChannel = 0U;
113  (config->triggerMode).samples = 0U;
114  (config->triggerMode).roundRobinChannelsState = 0U;
115  (config->triggerMode).programedState = 0U;
116 
117 #if FEATURE_CMP_HAS_INIT_DELAY
118  (config->triggerMode).initializationDelay = 0U;
119 #endif
120 
121 #if FEATURE_CMP_HAS_HARD_BLOCK_OFFSET
122  (config->comparator).offsetLevel = CMP_LEVEL_OFFSET_0;
123 #endif
124 
125 #if FEATURE_CMP_DAC_FIX_SELECTION
126  (config->dac).fixRefInputMux = false;
127 #endif
128 
129  return status;
130 }
131 /*FUNCTION**********************************************************************
132  *
133  * Function Name : CMP_DRV_Init
134  * Description : Configure all components from comparator module.
135  *
136  * Implements : CMP_DRV_Init_Activity
137  *END**************************************************************************/
138 status_t CMP_DRV_Init(const uint32_t instance, const cmp_module_t* const config)
139 {
140  status_t status = STATUS_SUCCESS;
141  DEV_ASSERT(config != NULL);
142  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
143  CMP_Type* base = g_cmpBase[instance];
144  CMP_SetDMATriggerState(base, (config->comparator).dmaTriggerState );
145  CMP_SetOutputInterruptTrigger(base, (config->comparator).outputInterruptTrigger);
146  CMP_SetFunctionalMode(base, (config->comparator).mode, (config->comparator).filterSampleCount, (config->comparator).filterSamplePeriod);
147  CMP_SetPowerMode(base, (config->comparator).powerMode);
148  CMP_SetInverterState(base, (config->comparator).inverterState);
149  CMP_SetComparatorOutputSource(base, (config->comparator).outputSelect);
150  CMP_SetOutputPinState(base, (config->comparator).pinState);
151  CMP_SetHysteresis(base, (config->comparator).hysteresisLevel);
152  CMP_SetDACState(base, (config->dac).state);
153  CMP_SetVoltageReference(base, (config->dac).voltageReferenceSource);
154  CMP_SetVoltage(base, (config->dac).voltage);
155  CMP_SetMinusMUXControl(base, (config->mux).negativeInputMux);
156  CMP_SetPlusMuxControl(base, (config->mux).positiveInputMux);
157  CMP_SetNegativePortInput(base, (config->mux).negativePortMux);
158  CMP_SetPositivePortInput(base, (config->mux).positivePortMux);
159  CMP_SetFixedPort(base, (config->triggerMode).fixedPort);
160  CMP_SetFixedChannel(base, (config->triggerMode).fixedChannel);
161  CMP_SetRoundRobinSamplesNumber(base, (config->triggerMode).samples);
162  CMP_SetRoundRobinChannels(base, (config->triggerMode).roundRobinChannelsState);
163  CMP_SetPresetState(base, (config->triggerMode).programedState);
164  CMP_SetRoundRobinInterruptState(base, (config->triggerMode).roundRobinInterruptState);
165  CMP_SetRoundRobinState(base, (config->triggerMode).roundRobinState);
166 
167 #if FEATURE_CMP_HAS_HARD_BLOCK_OFFSET
168  CMP_SetOffset(base, (config->comparator).offsetLevel);
169 #endif
170 
171 #if FEATURE_CMP_HAS_INIT_DELAY
172  CMP_SetInitDelay(base, (config->triggerMode).initializationDelay);
173 #endif
174 
175 #if FEATURE_CMP_DAC_FIX_SELECTION
176  CMP_SetFixedDACState(base, (config->dac).fixRefInputMux);
177 #endif
178 
179  /* Clear all flags*/
180  (void)CMP_DRV_ClearOutputFlags(instance);
181  (void)CMP_DRV_ClearInputFlags(instance);
182  return status;
183 }
184 /*FUNCTION**********************************************************************
185  *
186  * Function Name : CMP_DRV_GetConfigAll
187  * Description : This function returns the configuration for all components
188  * from comparator module.
189  * Implements : CMP_DRV_GetConfigAll_Activity
190  *
191  *END**************************************************************************/
192 status_t CMP_DRV_GetConfigAll(const uint32_t instance, cmp_module_t* const config)
193 {
194  status_t status = STATUS_SUCCESS;
195  DEV_ASSERT(config != NULL);
196  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
197  const CMP_Type* base = g_cmpBase[instance];
198  (config->comparator).dmaTriggerState = CMP_GetDMATriggerState(base);
199  (config->comparator).outputInterruptTrigger = CMP_GetOutputInterruptTrigger(base);
200  (config->comparator).mode = CMP_GetFunctionalMode(base);
201  (config->comparator).filterSampleCount = CMP_GetFilterSampleCount(base);
202  (config->comparator).filterSamplePeriod = CMP_GetFilterSamplePeriod(base);
203  (config->comparator).powerMode = CMP_GetPowerMode(base);
204  (config->comparator).inverterState = CMP_GetInverterState(base);
205  (config->comparator).outputSelect = CMP_GetComparatorOutputSource(base);
206  (config->comparator).pinState = CMP_GetOutputPinState(base);
207  (config->comparator).hysteresisLevel = CMP_GetHysteresis(base);
208  (config->dac).state = CMP_GetDACState(base);
209  (config->dac).voltageReferenceSource = CMP_GetVoltageReference(base);
210  (config->dac).voltage = CMP_GetVoltage(base);
211  (config->mux).negativePortMux = CMP_GetNegativePortInput(base);
212  (config->mux).positivePortMux = CMP_GetPositivePortInput(base);
213  (config->mux).negativeInputMux = CMP_GetMinusMUXControl(base);
214  (config->mux).positiveInputMux = CMP_GetPlusMUXControl(base);
215  (config->triggerMode).roundRobinState = CMP_GetRoundRobinState(base);
216  (config->triggerMode).roundRobinInterruptState = CMP_GetRoundRobinInterruptState(base);
217  (config->triggerMode).fixedPort = CMP_GetFixedPort(base);
218  (config->triggerMode).fixedChannel = CMP_GetFixedChannel(base);
219  (config->triggerMode).samples = CMP_GetRoundRobinSamplesNumber(base);
220  (config->triggerMode).roundRobinChannelsState = CMP_GetRoundRobinChannels(base);
221  (config->triggerMode).programedState = CMP_GetLastComparisonResult(base);
222 
223 #if FEATURE_CMP_HAS_HARD_BLOCK_OFFSET
224  (config->comparator).offsetLevel = CMP_GetOffset(base);
225 #endif
226 
227 #if FEATURE_CMP_HAS_INIT_DELAY
228  (config->triggerMode).initializationDelay = CMP_GetInitDelay(base);
229 #endif
230 
231 #if FEATURE_CMP_DAC_FIX_SELECTION
232  (config->dac).fixRefInputMux = CMP_GetFixedDACState(base);
233 #endif
234 
235  return status;
236 }
237 /*FUNCTION**********************************************************************
238  *
239  * Function Name : CMP_DRV_GetInitConfigDAC
240  * Description : Return configuration structure with reset values for DAC
241  * component from comparator module.
242  * Implements : CMP_DRV_GetInitConfigDAC_Activity
243  *
244  *END**************************************************************************/
246 {
247  status_t status = STATUS_SUCCESS;
248  DEV_ASSERT(config != NULL);
249  config->state = false;
251  config->voltage = 0U;
252 
253 #if FEATURE_CMP_DAC_FIX_SELECTION
254  config->fixRefInputMux = false;
255 #endif
256 
257  return status;
258 }
259 /*FUNCTION**********************************************************************
260  *
261  * Function Name : CMP_DRV_ConfigDAC
262  * Description : Configure only DAC component from comparator module.
263  * Implements : CMP_DRV_ConfigDAC_Activity
264  *
265  *END**************************************************************************/
266 status_t CMP_DRV_ConfigDAC(const uint32_t instance, const cmp_dac_t* config)
267 {
268  status_t status = STATUS_SUCCESS;
269  DEV_ASSERT(config != NULL);
270  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
271 #if CMP_DAC_RESOLUTION != 255U
273 #endif
274  CMP_Type* base = g_cmpBase[instance];
275  CMP_SetDACState(base, config->state);
276  CMP_SetVoltageReference(base, config->voltageReferenceSource);
277  CMP_SetVoltage(base, config->voltage);
278 #if FEATURE_CMP_DAC_FIX_SELECTION
279  CMP_SetFixedDACState(base, config->fixRefInputMux);
280 #endif
281  return status;
282 }
283 /*FUNCTION**********************************************************************
284  *
285  * Function Name : CMP_DRV_GetDAC
286  * Description : Return configuration for DAC component from comparator module.
287  * Implements : CMP_DRV_GetDACConfig_Activity
288  *
289  *END**************************************************************************/
290 status_t CMP_DRV_GetDACConfig(const uint32_t instance, cmp_dac_t* const config)
291 {
292  status_t status = STATUS_SUCCESS;
293  DEV_ASSERT(config != NULL);
294  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
295  const CMP_Type* base = g_cmpBase[instance];
296  config->state = CMP_GetDACState(base);
297  config->voltageReferenceSource = CMP_GetVoltageReference(base);
298  config->voltage = CMP_GetVoltage(base);
299 #if FEATURE_CMP_DAC_FIX_SELECTION
300  config->fixRefInputMux = CMP_GetFixedDACState(base);
301 #endif
302  return status;
303 }
304 /*FUNCTION**********************************************************************
305  *
306  * Function Name : CMP_DRV_GetInitConfigMUX
307  * Description : Return configuration structure with reset values for
308  * the MUX component which select source signals for comparator ports.
309  * Implements : CMP_DRV_GetInitConfigMUX_Activity
310  *
311  *END**************************************************************************/
313 {
314  status_t status = STATUS_SUCCESS;
315  DEV_ASSERT(config != NULL);
316  config->negativePortMux = CMP_DAC;
317  config->positivePortMux = CMP_DAC;
318  config->negativeInputMux = 0U;
319  config->positiveInputMux = 0U;
320 
321  return status;
322 }
323 /*FUNCTION**********************************************************************
324  *
325  * Function Name : CMP_DRV_ConfigMUX
326  * Description : Configure only MUX component from comparator module to select
327  * source signals for comparator ports.
328  * Implements : CMP_DRV_ConfigMUX_Activity
329  *
330  *END**************************************************************************/
331 status_t CMP_DRV_ConfigMUX(const uint32_t instance, const cmp_anmux_t* config)
332 {
333  status_t status = STATUS_SUCCESS;
334  DEV_ASSERT(config != NULL);
335  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
336  CMP_Type* base = g_cmpBase[instance];
337 
338  CMP_SetNegativePortInput(base, config->negativePortMux);
339  CMP_SetPositivePortInput(base, config->positivePortMux);
340  CMP_SetMinusMUXControl(base, config->negativeInputMux);
341  CMP_SetPlusMuxControl(base, config->positiveInputMux);
342  return status;
343 }
344 /*FUNCTION**********************************************************************
345  *
346  * Function Name : CMP_DRV_GetMUX
347  * Description : Return configuration for the MUX component which select
348  * source signals for comparator ports.
349  * Implements : CMP_DRV_GetMUXConfig_Activity
350  *
351  *END**************************************************************************/
352 status_t CMP_DRV_GetMUXConfig(const uint32_t instance, cmp_anmux_t* const config)
353 {
354  status_t status = STATUS_SUCCESS;
355  DEV_ASSERT(config != NULL);
356  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
357  const CMP_Type* base = g_cmpBase[instance];
358  config->negativePortMux = CMP_GetNegativePortInput(base);
359  config->positivePortMux = CMP_GetPositivePortInput(base);
360  config->negativeInputMux = CMP_GetMinusMUXControl(base);
361  config->positiveInputMux = CMP_GetPlusMUXControl(base);
362  return status;
363 }
364 /*FUNCTION**********************************************************************
365  *
366  * Function Name : CMP_DRV_GetInitTriggerMode
367  * Description : Return configuration structure with reset values for Trigger Mode
368  * from comparator module.
369  * Implements : CMP_DRV_GetInitTriggerMode_Activity
370  *
371  *END**************************************************************************/
373 {
374  status_t status = STATUS_SUCCESS;
375  DEV_ASSERT(config != NULL);
376  config->roundRobinState = false;
377  config->roundRobinInterruptState = false;
378  config->fixedPort = CMP_PLUS_FIXED;
379  config->fixedChannel = 0U;
380  config->samples = 0U;
381  config->roundRobinChannelsState = 0U;
382  config->programedState = 0U;
383 #if FEATURE_CMP_HAS_INIT_DELAY
384  config->initializationDelay = 0U;
385 #endif
386  return status;
387 }
388 /*FUNCTION**********************************************************************
389  *
390  * Function Name : CMP_DRV_ConfigTriggerMode
391  * Description : Configure comparator in trigger mode.
392  * Implements : CMP_DRV_ConfigTriggerMode_Activity
393  *
394  *END**************************************************************************/
395 status_t CMP_DRV_ConfigTriggerMode(const uint32_t instance, const cmp_trigger_mode_t* config)
396 {
397  status_t status = STATUS_SUCCESS;
398  DEV_ASSERT(config != NULL);
399  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
400  CMP_Type* base = g_cmpBase[instance];
401  CMP_SetRoundRobinState(base, config->roundRobinState);
402  CMP_SetRoundRobinInterruptState(base, config->roundRobinInterruptState);
403  CMP_SetFixedPort(base, config->fixedPort);
404  CMP_SetFixedChannel(base, config->fixedChannel);
405  CMP_SetRoundRobinSamplesNumber(base, config->samples);
406 
407 #if FEATURE_CMP_HAS_INIT_DELAY
408  CMP_SetInitDelay(base, config->initializationDelay);
409 #endif
410 
411  CMP_SetRoundRobinChannels(base, config->roundRobinChannelsState);
412  CMP_SetPresetState(base, config->programedState);
413  return status;
414 }
415 /*FUNCTION**********************************************************************
416  *
417  * Function Name : CMP_DRV_GetTriggerMode
418  * Description : Return configuration for the trigger mode.
419  * Implements : CMP_DRV_GetTriggerModeConfig_Activity
420  *
421  *END**************************************************************************/
422 status_t CMP_DRV_GetTriggerModeConfig(const uint32_t instance, cmp_trigger_mode_t* const config)
423 {
424  status_t status = STATUS_SUCCESS;
425  DEV_ASSERT(config != NULL);
426  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
427  const CMP_Type* base = g_cmpBase[instance];
428  config->roundRobinState = CMP_GetRoundRobinState(base);
429  config->roundRobinInterruptState = CMP_GetRoundRobinInterruptState(base);
430  config->fixedPort = CMP_GetFixedPort(base);
431  config->fixedChannel = CMP_GetFixedChannel(base);
432  config->samples = CMP_GetRoundRobinSamplesNumber(base);
433  config->roundRobinChannelsState = CMP_GetRoundRobinChannels(base);
434  config->programedState = CMP_GetLastComparisonResult(base);
435 
436 #if FEATURE_CMP_HAS_INIT_DELAY
437  config->initializationDelay = CMP_GetInitDelay(base);
438 #endif
439 
440  return status;
441 }
442 /*FUNCTION**********************************************************************
443  *
444  * Function Name : CMP_DRV_GetOutputFlags
445  * Description : Return in <flags> comparator output flags(rising and falling edge on output).
446  * Implements : CMP_DRV_GetOutputFlags_Activity
447  *
448  *END**************************************************************************/
449 status_t CMP_DRV_GetOutputFlags(const uint32_t instance, cmp_output_trigger_t *flags)
450 {
451  status_t status = STATUS_SUCCESS;
452  DEV_ASSERT(flags != NULL);
453  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
454  const CMP_Type* baseAddr = g_cmpBase[instance];
455  bool rising_enabled = (bool)(((baseAddr->C0) >> CMP_C0_CFR_SHIFT) & (uint32_t)1U);
456  bool falling_enabled = (bool)(((baseAddr->C0) >> CMP_C0_CFF_SHIFT) & (uint32_t)1U);
457  *flags = (cmp_output_trigger_t) (((uint32_t)rising_enabled << (uint32_t)1U) | ((uint32_t)falling_enabled));
458  return status;
459 }
460 /*FUNCTION**********************************************************************
461  *
462  * Function Name : CMP_DRV_ClearOutputFlags
463  * Description : Clear comparator output flags(rising and falling edge on output).
464  * Implements : CMP_DRV_ClearOutputFlags_Activity
465  *
466  *END**************************************************************************/
467 status_t CMP_DRV_ClearOutputFlags(const uint32_t instance)
468 {
469  status_t status = STATUS_SUCCESS;
470  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
471  CMP_Type* baseAddr = g_cmpBase[instance];
472 
473  uint32_t tmp = baseAddr->C0;
474  tmp &= ~(CMP_C0_CFR_MASK);
475  tmp |= CMP_C0_CFR(1);
476  tmp &= ~(CMP_C0_CFF_MASK);
477  tmp |= CMP_C0_CFF(1);
478  baseAddr->C0 = tmp;
479 
480  #ifdef ERRATA_E9005
481  (void)baseAddr->C0;
482  #endif
483  return status;
484  }
485 
486  /*FUNCTION**********************************************************************
487  *
488  * Function Name : CMP_DRV_GetInputFlags
489  * Description : Return all input change flags in <flags>.
490  * <flags> format : Flag_Ch7 Flag_Ch6 ... Flag_Ch0
491  * Implements : CMP_DRV_GetInputFlags_Activity
492  *
493  *END**************************************************************************/
494 status_t CMP_DRV_GetInputFlags(const uint32_t instance, cmp_ch_list_t *flags)
495 {
496  status_t status = STATUS_SUCCESS;
497  DEV_ASSERT(flags != NULL);
498  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
499  const CMP_Type* baseAddr = g_cmpBase[instance];
500 
501  uint32_t tmp = baseAddr->C2;
502  *flags = (cmp_ch_list_t)((tmp & (uint32_t)CMP_INPUT_FLAGS_MASK) >> CMP_INPUT_FLAGS_SHIFT);
503  return status;
504  }
505  /*FUNCTION**********************************************************************
506  *
507  * Function Name : CMP_DRV_ClearInputFlags
508  * Description : Clear all input change flags .
509  * Implements : CMP_DRV_ClearInputFlags_Activity
510  *
511  *END**************************************************************************/
512 status_t CMP_DRV_ClearInputFlags(const uint32_t instance)
513 {
514  status_t status = STATUS_SUCCESS;
515  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
516  CMP_Type* baseAddr = g_cmpBase[instance];
517 
518  uint32_t tmp = baseAddr->C2;
519  tmp |= (uint32_t)CMP_INPUT_FLAGS_MASK;
520  baseAddr->C2 = tmp;
521  #ifdef ERRATA_E9005
522  (void)baseAddr->C2;
523  #endif
524  return status;
525 }
526 /*FUNCTION**********************************************************************
527  *
528  * Function Name : CMP_DRV_GetInitConfigComparator
529  * Description : Return configuration structure with reset values for comparator features (functional mode, power mode,
530  * inverter, hysteresis, offset, filter sampling period and samples count).
531  * Implements : CMP_DRV_GetInitConfigComparator_Activity
532  *
533  *END**************************************************************************/
535 {
536  status_t status = STATUS_SUCCESS;
537  DEV_ASSERT(config != NULL);
539  config->dmaTriggerState = false;
540  config->mode = CMP_DISABLED;
541  config->filterSampleCount = 0U;
542  config->filterSamplePeriod = 0U;
543  config->powerMode = CMP_LOW_SPEED;
544  config->inverterState = CMP_NORMAL;
545  config->outputSelect = CMP_COUT;
546  config->pinState = CMP_UNAVAILABLE;
547 #if FEATURE_CMP_HAS_HARD_BLOCK_OFFSET
549 #endif
551  return status;
552 }
553 /*FUNCTION**********************************************************************
554  *
555  * Function Name : CMP_DRV_ConfigComparator
556  * Description : Configure only comparator features (functional mode, power mode,
557  * inverter, hysteresis, offset, filter sampling period and samples count).
558  * Implements : CMP_DRV_ConfigComparator_Activity
559  *
560  *END**************************************************************************/
561 status_t CMP_DRV_ConfigComparator(const uint32_t instance, const cmp_comparator_t *config)
562 {
563  status_t status = STATUS_SUCCESS;
564  DEV_ASSERT(config != NULL);
565  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
566  CMP_Type* base = g_cmpBase[instance];
567  CMP_SetDMATriggerState(base, config->dmaTriggerState );
568  CMP_SetOutputInterruptTrigger(base, config->outputInterruptTrigger);
569  CMP_SetFunctionalMode(base, config->mode, config->filterSampleCount, config->filterSamplePeriod);
570  CMP_SetFilterSamplePeriod(base, config->filterSampleCount );
571  CMP_SetFilterSampleCount(base, config->filterSamplePeriod);
572  CMP_SetPowerMode(base, config->powerMode);
573  CMP_SetInverterState(base, config->inverterState);
574  CMP_SetComparatorOutputSource(base, config->outputSelect);
575  CMP_SetOutputPinState(base, config->pinState);
576 
577 #if FEATURE_CMP_HAS_HARD_BLOCK_OFFSET
578  CMP_SetOffset(base, config->offsetLevel);
579 #endif
580 
581  CMP_SetHysteresis(base, config->hysteresisLevel);
582  return status;
583 }
584 /*FUNCTION**********************************************************************
585  *
586  * Function Name : CMP_DRV_GetComparator
587  * Description : Return configuration for comparator components from CMP module.
588  * Implements : CMP_DRV_GetComparatorConfig_Activity
589  *
590  *END**************************************************************************/
591 status_t CMP_DRV_GetComparatorConfig(const uint32_t instance, cmp_comparator_t *config)
592 {
593  status_t status = STATUS_SUCCESS;
594  DEV_ASSERT(config != NULL);
595  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
596  const CMP_Type* base = g_cmpBase[instance];
597  config->dmaTriggerState = CMP_GetDMATriggerState(base);
598  config->outputInterruptTrigger = CMP_GetOutputInterruptTrigger(base);
599  config->mode = CMP_GetFunctionalMode(base);
600  config->filterSampleCount = CMP_GetFilterSamplePeriod(base);
601  config->filterSamplePeriod = CMP_GetFilterSampleCount(base);
602  config->powerMode = CMP_GetPowerMode(base);
603  config->inverterState = CMP_GetInverterState(base);
604  config->outputSelect = CMP_GetComparatorOutputSource(base);
605  config->pinState = CMP_GetOutputPinState(base);
606 
607 #if FEATURE_CMP_HAS_HARD_BLOCK_OFFSET
608  config->offsetLevel = CMP_GetOffset(base);
609 #endif
610 
611  config->hysteresisLevel = CMP_GetHysteresis(base);
612  return status;
613 }
614 /******************************************************************************
615  * EOF
616  *****************************************************************************/
617 
status_t CMP_DRV_GetComparatorConfig(const uint32_t instance, cmp_comparator_t *config)
Return configuration for comparator from CMP module.
Definition: cmp_driver.c:591
cmp_ch_number_t fixedChannel
Definition: cmp_driver.h:251
uint8_t initializationDelay
Definition: cmp_driver.h:254
cmp_fixed_port_t fixedPort
Definition: cmp_driver.h:249
status_t CMP_DRV_GetDACConfig(const uint32_t instance, cmp_dac_t *const config)
Return current configuration for DAC.
Definition: cmp_driver.c:290
status_t CMP_DRV_ConfigTriggerMode(const uint32_t instance, const cmp_trigger_mode_t *config)
Configure trigger mode.
Definition: cmp_driver.c:395
cmp_ch_number_t positiveInputMux
Definition: cmp_driver.h:215
#define CMP_BASE_PTRS
Definition: S32K118.h:1619
status_t CMP_DRV_GetInitTriggerMode(cmp_trigger_mode_t *config)
Get reset configuration for registers related with Trigger Mode.
Definition: cmp_driver.c:372
#define C1_RESET_VALUE
volatile uint32_t C2
Definition: S32K118.h:1604
static CMP_Type *const g_cmpBase[]
Definition: cmp_driver.c:61
volatile uint32_t C1
Definition: S32K118.h:1603
cmp_anmux_t mux
Definition: cmp_driver.h:272
status_t CMP_DRV_ConfigDAC(const uint32_t instance, const cmp_dac_t *config)
Configure only the DAC component.
Definition: cmp_driver.c:266
status_t CMP_DRV_GetInitConfigComparator(cmp_comparator_t *config)
Get reset configuration for registers related with comparator features.
Definition: cmp_driver.c:534
#define CMP_DAC_RESOLUTION
status_t CMP_DRV_GetTriggerModeConfig(const uint32_t instance, cmp_trigger_mode_t *const config)
Get current trigger mode configuration.
Definition: cmp_driver.c:422
#define CMP_C0_CFR(x)
Definition: S32K118.h:1692
Defines the analog mux.
Definition: cmp_driver.h:206
bool roundRobinInterruptState
Definition: cmp_driver.h:248
bool state
Definition: cmp_driver.h:230
Defines the trigger mode.
Definition: cmp_driver.h:245
status_t CMP_DRV_ClearInputFlags(const uint32_t instance)
Clear comparator input channels flags.
Definition: cmp_driver.c:512
#define DEV_ASSERT(x)
Definition: devassert.h:77
#define CMP_INPUT_FLAGS_MASK
Definition: cmp_driver.h:33
status_t CMP_DRV_GetOutputFlags(const uint32_t instance, cmp_output_trigger_t *flags)
Get comparator output flags.
Definition: cmp_driver.c:449
uint8_t voltage
Definition: cmp_driver.h:229
status_t CMP_DRV_GetConfigAll(const uint32_t instance, cmp_module_t *const config)
Gets the current comparator configuration.
Definition: cmp_driver.c:192
cmp_ch_list_t roundRobinChannelsState
Definition: cmp_driver.h:256
cmp_output_trigger_t
Comparator output interrupt configuration Implements : cmp_output_trigger_t_Class.
Definition: cmp_driver.h:129
uint8_t filterSamplePeriod
Definition: cmp_driver.h:180
Defines the comparator module configuration.
Definition: cmp_driver.h:269
status_t CMP_DRV_ConfigMUX(const uint32_t instance, const cmp_anmux_t *config)
Configure only the MUX component.
Definition: cmp_driver.c:331
status_t CMP_DRV_GetInitConfigMUX(cmp_anmux_t *config)
Get reset configuration for registers related with MUX.
Definition: cmp_driver.c:312
status_t CMP_DRV_GetInputFlags(const uint32_t instance, cmp_ch_list_t *flags)
Gets input channels change flags.
Definition: cmp_driver.c:494
cmp_voltage_reference_t voltageReferenceSource
Definition: cmp_driver.h:227
status_t CMP_DRV_ConfigComparator(const uint32_t instance, const cmp_comparator_t *config)
Configure only comparator features.
Definition: cmp_driver.c:561
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
Definition: status.h:44
status_t CMP_DRV_Reset(const uint32_t instance)
Reset all registers.
Definition: cmp_driver.c:69
cmp_output_enable_t pinState
Definition: cmp_driver.h:186
status_t CMP_DRV_GetInitConfigAll(cmp_module_t *config)
Get reset configuration for all registers.
Definition: cmp_driver.c:88
#define CMP_C0_CFF_SHIFT
Definition: S32K118.h:1686
status_t CMP_DRV_Init(const uint32_t instance, const cmp_module_t *const config)
Configure all comparator features with the given configuration structure.
Definition: cmp_driver.c:138
#define CMP_C0_CFR_SHIFT
Definition: S32K118.h:1690
volatile uint32_t C0
Definition: S32K118.h:1602
cmp_ch_number_t negativeInputMux
Definition: cmp_driver.h:216
#define C0_RESET_VALUE
cmp_port_mux_t positivePortMux
Definition: cmp_driver.h:208
#define CMP_INSTANCE_COUNT
Definition: S32K118.h:1608
uint8_t cmp_ch_list_t
Comparator channels list (1bit/channel) |------—|------—|--—|------—|------—| |CH7_state|CH6_sta...
Definition: cmp_driver.h:159
#define CMP_C0_CFR_MASK
Definition: S32K118.h:1689
cmp_comparator_t comparator
Definition: cmp_driver.h:271
cmp_mode_t mode
Definition: cmp_driver.h:179
cmp_dac_t dac
Definition: cmp_driver.h:273
cmp_output_select_t outputSelect
Definition: cmp_driver.h:188
cmp_offset_t offsetLevel
Definition: cmp_driver.h:191
status_t CMP_DRV_GetInitConfigDAC(cmp_dac_t *config)
Get reset configuration for registers related with DAC.
Definition: cmp_driver.c:245
Defines the block configuration.
Definition: cmp_driver.h:172
cmp_hysteresis_t hysteresisLevel
Definition: cmp_driver.h:194
status_t CMP_DRV_ClearOutputFlags(const uint32_t instance)
Clear comparator output flags.
Definition: cmp_driver.c:467
uint8_t filterSampleCount
Definition: cmp_driver.h:181
#define CMP_C0_CFF_MASK
Definition: S32K118.h:1685
#define CMP_INPUT_FLAGS_SHIFT
Definition: cmp_driver.h:34
cmp_trigger_mode_t triggerMode
Definition: cmp_driver.h:274
cmp_output_trigger_t outputInterruptTrigger
Definition: cmp_driver.h:175
#define CMP_C0_CFF(x)
Definition: S32K118.h:1688
status_t CMP_DRV_GetMUXConfig(const uint32_t instance, cmp_anmux_t *const config)
Return configuration only for the MUX component.
Definition: cmp_driver.c:352
Defines the DAC block.
Definition: cmp_driver.h:225
cmp_ch_list_t programedState
Definition: cmp_driver.h:260
cmp_power_mode_t powerMode
Definition: cmp_driver.h:182
cmp_inverter_t inverterState
Definition: cmp_driver.h:184
cmp_port_mux_t negativePortMux
Definition: cmp_driver.h:211