S32 SDK
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 
75  baseAddr->C0 = CMP_C0_DMAEN(0U) | CMP_C0_IER(0U) | CMP_C0_IEF(0U) | CMP_C0_CFR(1U) |
76  CMP_C0_CFF(1U) | CMP_C0_FPR(0U) | CMP_C0_SE(0U) | CMP_C0_WE(0U) |
77  CMP_C0_PMODE(0U) | CMP_C0_INVT(0U) | CMP_C0_COS(0U) | CMP_C0_OPE(0U) |
79 
80  baseAddr->C1 = CMP_C1_INPSEL(0U) | CMP_C1_INNSEL(0U) | CMP_C1_CHN7(0U) |
81  CMP_C1_CHN6(0U) | CMP_C1_CHN5(0U) | CMP_C1_CHN4(0U) | CMP_C1_CHN3(0U) | CMP_C1_CHN2(0U) |
82  CMP_C1_CHN1(0U) | CMP_C1_CHN0(0U) | CMP_C1_DACEN(0U) | CMP_C1_VRSEL(0U) |
83  CMP_C1_PSEL(0U) | CMP_C1_MSEL(0U) | CMP_C1_VOSEL(0U);
84 
85  baseAddr->C2 = CMP_C2_RRE(0U) | CMP_C2_RRIE(0U) | CMP_C2_FXMP(0U) | CMP_C2_FXMXCH(0U) | CMP_C2_CH7F(1U) |
86  CMP_C2_CH6F(1U) | CMP_C2_CH5F(1U) | CMP_C2_CH4F(1U) | CMP_C2_CH3F(1U) | CMP_C2_CH2F(1U) |
87  CMP_C2_CH1F(1U) | CMP_C2_CH0F(1U) | CMP_C2_NSAM(0U) | CMP_C2_NSAM(0U) | CMP_C2_INITMOD(0U) |
88  CMP_C2_ACOn(0U);
89  return status;
90 }
91 /*FUNCTION**********************************************************************
92  *
93  * Function Name : CMP_DRV_GetInitConfigAll
94  * Description : Return a configuration structure with reset values for all components
95  * from comparator module.
96  * Implements : CMP_DRV_GetInitConfigAll_Activity
97  *
98  *END**************************************************************************/
100 {
101  status_t status = STATUS_SUCCESS;
102  DEV_ASSERT(config != NULL);
103  (config->comparator).outputInterruptTrigger = CMP_NO_EVENT;
104  (config->comparator).mode = CMP_DISABLED;
105  (config->comparator).filterSampleCount = 0U;
106  (config->comparator).filterSamplePeriod = 0U;
107  (config->comparator).powerMode = CMP_LOW_SPEED;
108  (config->comparator).inverterState = CMP_NORMAL;
109  (config->comparator).outputSelect = CMP_COUT;
110  (config->comparator).pinState = CMP_UNAVAILABLE;
111  (config->comparator).offsetLevel = CMP_LEVEL_OFFSET_0;
112  (config->comparator).hysteresisLevel = CMP_LEVEL_HYS_0;
113  (config->dac).state = false;
114  (config->dac).voltageReferenceSource = CMP_VIN1;
115  (config->dac).voltage = 0U;
116  (config->mux).negativePortMux = CMP_DAC;
117  (config->mux).positivePortMux = CMP_DAC;
118  (config->mux).negativeInputMux = 0U;
119  (config->mux).positiveInputMux = 0U;
120  (config->triggerMode).roundRobinState = false;
121  (config->triggerMode).roundRobinInterruptState = false;
122  (config->triggerMode).fixedPort = CMP_PLUS_FIXED;
123  (config->triggerMode).fixedChannel = 0U;
124  (config->triggerMode).samples = 0U;
125  (config->triggerMode).roundRobinChannelsState = 0U;
126  (config->triggerMode).programedState = 0U;
127  (config->triggerMode).initializationDelay = 0U;
128  return status;
129 }
130 /*FUNCTION**********************************************************************
131  *
132  * Function Name : CMP_DRV_Init
133  * Description : Configure all components from comparator module.
134  *
135  * Implements : CMP_DRV_Init_Activity
136  *END**************************************************************************/
137 status_t CMP_DRV_Init(const uint32_t instance, const cmp_module_t* const config)
138 {
139  status_t status = STATUS_SUCCESS;
140  DEV_ASSERT(config != NULL);
141  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
142  CMP_Type* base = g_cmpBase[instance];
143  CMP_SetDMATriggerState(base, (config->comparator).dmaTriggerState );
144  CMP_SetOutputInterruptTrigger(base, (config->comparator).outputInterruptTrigger);
145  CMP_SetFunctionalMode(base, (config->comparator).mode, (config->comparator).filterSampleCount, (config->comparator).filterSamplePeriod);
146  CMP_SetPowerMode(base, (config->comparator).powerMode);
147  CMP_SetInverterState(base, (config->comparator).inverterState);
148  CMP_SetComparatorOutputSource(base, (config->comparator).outputSelect);
149  CMP_SetOutputPinState(base, (config->comparator).pinState);
150  CMP_SetHysteresis(base, (config->comparator).hysteresisLevel);
151  CMP_SetOffset(base, (config->comparator).offsetLevel);
152  CMP_SetDACState(base, (config->dac).state);
153  CMP_SetVoltageReference(base, (config->dac).voltageReferenceSource);
154  CMP_SetVoltage(base, (config->dac).voltage);
155  CMP_SetNegativePortInput(base, (config->mux).negativePortMux);
156  CMP_SetPositivePortInput(base, (config->mux).positivePortMux);
157  CMP_SetMinusMUXControl(base, (config->mux).negativeInputMux);
158  CMP_SetPlusMuxControl(base, (config->mux).positiveInputMux);
159  CMP_SetFixedPort(base, (config->triggerMode).fixedPort);
160  CMP_SetFixedChannel(base, (config->triggerMode).fixedChannel);
161  CMP_SetRoundRobinSamplesNumber(base, (config->triggerMode).samples);
162  CMP_SetInitDelay(base, (config->triggerMode).initializationDelay);
163  CMP_SetRoundRobinChannels(base, (config->triggerMode).roundRobinChannelsState);
164  CMP_SetPresetState(base, (config->triggerMode).programedState);
165  CMP_SetRoundRobinInterruptState(base, (config->triggerMode).roundRobinInterruptState);
166  CMP_SetRoundRobinState(base, (config->triggerMode).roundRobinState);
167  /* Clear all flags*/
168  (void)CMP_DRV_ClearOutputFlags(instance);
169  (void)CMP_DRV_ClearInputFlags(instance);
170  return status;
171 }
172 /*FUNCTION**********************************************************************
173  *
174  * Function Name : CMP_DRV_GetConfigAll
175  * Description : This function returns the configuration for all components
176  * from comparator module.
177  * Implements : CMP_DRV_GetConfigAll_Activity
178  *
179  *END**************************************************************************/
180 status_t CMP_DRV_GetConfigAll(const uint32_t instance, cmp_module_t* const config)
181 {
182  status_t status = STATUS_SUCCESS;
183  DEV_ASSERT(config != NULL);
184  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
185  const CMP_Type* base = g_cmpBase[instance];
186  (config->comparator).dmaTriggerState = CMP_GetDMATriggerState(base);
187  (config->comparator).outputInterruptTrigger = CMP_GetOutputInterruptTrigger(base);
188  (config->comparator).mode = CMP_GetFunctionalMode(base);
189  (config->comparator).filterSampleCount = CMP_GetFilterSampleCount(base);
190  (config->comparator).filterSamplePeriod = CMP_GetFilterSamplePeriod(base);
191  (config->comparator).powerMode = CMP_GetPowerMode(base);
192  (config->comparator).inverterState = CMP_GetInverterState(base);
193  (config->comparator).outputSelect = CMP_GetComparatorOutputSource(base);
194  (config->comparator).pinState = CMP_GetOutputPinState(base);
195  (config->comparator).offsetLevel = CMP_GetOffset(base);
196  (config->comparator).hysteresisLevel = CMP_GetHysteresis(base);
197  (config->dac).state = CMP_GetDACState(base);
198  (config->dac).voltageReferenceSource = CMP_GetVoltageReference(base);
199  (config->dac).voltage = CMP_GetVoltage(base);
200  (config->mux).negativePortMux = CMP_GetNegativePortInput(base);
201  (config->mux).positivePortMux = CMP_GetPositivePortInput(base);
202  (config->mux).negativeInputMux = CMP_GetMinusMUXControl(base);
203  (config->mux).positiveInputMux = CMP_GetPlusMUXControl(base);
204  (config->triggerMode).roundRobinState = CMP_GetRoundRobinState(base);
205  (config->triggerMode).roundRobinInterruptState = CMP_GetRoundRobinInterruptState(base);
206  (config->triggerMode).fixedPort = CMP_GetFixedPort(base);
207  (config->triggerMode).fixedChannel = CMP_GetFixedChannel(base);
208  (config->triggerMode).samples = CMP_GetRoundRobinSamplesNumber(base);
209  (config->triggerMode).roundRobinChannelsState = CMP_GetRoundRobinChannels(base);
210  (config->triggerMode).programedState = CMP_GetLastComparisonResult(base);
211  (config->triggerMode).initializationDelay = CMP_GetInitDelay(base);
212  return status;
213 }
214 /*FUNCTION**********************************************************************
215  *
216  * Function Name : CMP_DRV_GetInitConfigDAC
217  * Description : Return configuration structure with reset values for DAC
218  * component from comparator module.
219  * Implements : CMP_DRV_GetInitConfigDAC_Activity
220  *
221  *END**************************************************************************/
223 {
224  status_t status = STATUS_SUCCESS;
225  DEV_ASSERT(config != NULL);
226  config->state = false;
228  config->voltage = 0U;
229  return status;
230 }
231 /*FUNCTION**********************************************************************
232  *
233  * Function Name : CMP_DRV_ConfigDAC
234  * Description : Configure only DAC component from comparator module.
235  * Implements : CMP_DRV_ConfigDAC_Activity
236  *
237  *END**************************************************************************/
238 status_t CMP_DRV_ConfigDAC(const uint32_t instance, const cmp_dac_t* config)
239 {
240  status_t status = STATUS_SUCCESS;
241  DEV_ASSERT(config != NULL);
242  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
243  CMP_Type* base = g_cmpBase[instance];
244  CMP_SetDACState(base, config->state);
245  CMP_SetVoltageReference(base, config->voltageReferenceSource);
246  CMP_SetVoltage(base, config->voltage);
247  return status;
248 }
249 /*FUNCTION**********************************************************************
250  *
251  * Function Name : CMP_DRV_GetDAC
252  * Description : Return configuration for DAC component from comparator module.
253  * Implements : CMP_DRV_GetDACConfig_Activity
254  *
255  *END**************************************************************************/
256 status_t CMP_DRV_GetDACConfig(const uint32_t instance, cmp_dac_t* const config)
257 {
258  status_t status = STATUS_SUCCESS;
259  DEV_ASSERT(config != NULL);
260  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
261  const CMP_Type* base = g_cmpBase[instance];
262  config->state = CMP_GetDACState(base);
263  config->voltageReferenceSource = CMP_GetVoltageReference(base);
264  config->voltage = CMP_GetVoltage(base);
265  return status;
266 }
267 /*FUNCTION**********************************************************************
268  *
269  * Function Name : CMP_DRV_GetInitConfigMUX
270  * Description : Return configuration structure with reset values for
271  * the MUX component which select source signals for comparator ports.
272  * Implements : CMP_DRV_GetInitConfigMUX_Activity
273  *
274  *END**************************************************************************/
276 {
277  status_t status = STATUS_SUCCESS;
278  DEV_ASSERT(config != NULL);
279  config->negativePortMux = CMP_DAC;
280  config->positivePortMux = CMP_DAC;
281  config->negativeInputMux = 0U;
282  config->positiveInputMux = 0U;
283  return status;
284 }
285 /*FUNCTION**********************************************************************
286  *
287  * Function Name : CMP_DRV_ConfigMUX
288  * Description : Configure only MUX component from comparator module to select
289  * source signals for comparator ports.
290  * Implements : CMP_DRV_ConfigMUX_Activity
291  *
292  *END**************************************************************************/
293 status_t CMP_DRV_ConfigMUX(const uint32_t instance, const cmp_anmux_t* config)
294 {
295  status_t status = STATUS_SUCCESS;
296  DEV_ASSERT(config != NULL);
297  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
298  CMP_Type* base = g_cmpBase[instance];
299  CMP_SetNegativePortInput(base, config->negativePortMux);
300  CMP_SetPositivePortInput(base, config->positivePortMux);
301  CMP_SetMinusMUXControl(base, config->negativeInputMux);
302  CMP_SetPlusMuxControl(base, config->positiveInputMux);
303  return status;
304 }
305 /*FUNCTION**********************************************************************
306  *
307  * Function Name : CMP_DRV_GetMUX
308  * Description : Return configuration for the MUX component which select
309  * source signals for comparator ports.
310  * Implements : CMP_DRV_GetMUXConfig_Activity
311  *
312  *END**************************************************************************/
313 status_t CMP_DRV_GetMUXConfig(const uint32_t instance, cmp_anmux_t* const config)
314 {
315  status_t status = STATUS_SUCCESS;
316  DEV_ASSERT(config != NULL);
317  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
318  const CMP_Type* base = g_cmpBase[instance];
319  config->negativePortMux = CMP_GetNegativePortInput(base);
320  config->positivePortMux = CMP_GetPositivePortInput(base);
321  config->negativeInputMux = CMP_GetMinusMUXControl(base);
322  config->positiveInputMux = CMP_GetPlusMUXControl(base);
323  return status;
324 }
325 /*FUNCTION**********************************************************************
326  *
327  * Function Name : CMP_DRV_GetInitTriggerMode
328  * Description : Return configuration structure with reset values for Trigger Mode
329  * from comparator module.
330  * Implements : CMP_DRV_GetInitTriggerMode_Activity
331  *
332  *END**************************************************************************/
334 {
335  status_t status = STATUS_SUCCESS;
336  DEV_ASSERT(config != NULL);
337  config->roundRobinState = false;
338  config->roundRobinInterruptState = false;
339  config->fixedPort = CMP_PLUS_FIXED;
340  config->fixedChannel = 0U;
341  config->samples = 0U;
342  config->roundRobinChannelsState = 0U;
343  config->programedState = 0U;
344  config->initializationDelay = 0U;
345  return status;
346 }
347 /*FUNCTION**********************************************************************
348  *
349  * Function Name : CMP_DRV_ConfigTriggerMode
350  * Description : Configure comparator in trigger mode.
351  * Implements : CMP_DRV_ConfigTriggerMode_Activity
352  *
353  *END**************************************************************************/
354 status_t CMP_DRV_ConfigTriggerMode(const uint32_t instance, const cmp_trigger_mode_t* config)
355 {
356  status_t status = STATUS_SUCCESS;
357  DEV_ASSERT(config != NULL);
358  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
359  CMP_Type* base = g_cmpBase[instance];
360  CMP_SetRoundRobinState(base, config->roundRobinState);
361  CMP_SetRoundRobinInterruptState(base, config->roundRobinInterruptState);
362  CMP_SetFixedPort(base, config->fixedPort);
363  CMP_SetFixedChannel(base, config->fixedChannel);
364  CMP_SetRoundRobinSamplesNumber(base, config->samples);
365  CMP_SetInitDelay(base, config->initializationDelay);
366  CMP_SetRoundRobinChannels(base, config->roundRobinChannelsState);
367  CMP_SetPresetState(base, config->programedState);
368  return status;
369 }
370 /*FUNCTION**********************************************************************
371  *
372  * Function Name : CMP_DRV_GetTriggerMode
373  * Description : Return configuration for the trigger mode.
374  * Implements : CMP_DRV_GetTriggerModeConfig_Activity
375  *
376  *END**************************************************************************/
377 status_t CMP_DRV_GetTriggerModeConfig(const uint32_t instance, cmp_trigger_mode_t* const config)
378 {
379  status_t status = STATUS_SUCCESS;
380  DEV_ASSERT(config != NULL);
381  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
382  const CMP_Type* base = g_cmpBase[instance];
383  config->roundRobinState = CMP_GetRoundRobinState(base);
384  config->roundRobinInterruptState = CMP_GetRoundRobinInterruptState(base);
385  config->fixedPort = CMP_GetFixedPort(base);
386  config->fixedChannel = CMP_GetFixedChannel(base);
387  config->samples = CMP_GetRoundRobinSamplesNumber(base);
388  config->roundRobinChannelsState = CMP_GetRoundRobinChannels(base);
389  config->programedState = CMP_GetLastComparisonResult(base);
390  config->initializationDelay = CMP_GetInitDelay(base);
391  return status;
392 }
393 /*FUNCTION**********************************************************************
394  *
395  * Function Name : CMP_DRV_GetOutputFlags
396  * Description : Return in <flags> comparator output flags(rising and falling edge on output).
397  * Implements : CMP_DRV_GetOutputFlags_Activity
398  *
399  *END**************************************************************************/
400 status_t CMP_DRV_GetOutputFlags(const uint32_t instance, cmp_output_trigger_t *flags)
401 {
402  status_t status = STATUS_SUCCESS;
403  DEV_ASSERT(flags != NULL);
404  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
405  const CMP_Type* baseAddr = g_cmpBase[instance];
406  bool rising_enabled = (bool)(((baseAddr->C0) >> CMP_C0_CFR_SHIFT) & (uint32_t)1U);
407  bool falling_enabled = (bool)(((baseAddr->C0) >> CMP_C0_CFF_SHIFT) & (uint32_t)1U);
408  *flags = (cmp_output_trigger_t) (((uint32_t)rising_enabled << (uint32_t)1U) | ((uint32_t)falling_enabled));
409  return status;
410 }
411 /*FUNCTION**********************************************************************
412  *
413  * Function Name : CMP_DRV_ClearOutputFlags
414  * Description : Clear comparator output flags(rising and falling edge on output).
415  * Implements : CMP_DRV_ClearOutputFlags_Activity
416  *
417  *END**************************************************************************/
418 status_t CMP_DRV_ClearOutputFlags(const uint32_t instance)
419 {
420  status_t status = STATUS_SUCCESS;
421  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
422  CMP_Type* baseAddr = g_cmpBase[instance];
423 
424  uint32_t tmp = baseAddr->C0;
425  tmp &= ~(CMP_C0_CFR_MASK);
426  tmp |= CMP_C0_CFR(1);
427  tmp &= ~(CMP_C0_CFF_MASK);
428  tmp |= CMP_C0_CFF(1);
429  baseAddr->C0 = tmp;
430 
431  #ifdef ERRATA_E9005
432  (void)baseAddr->C0;
433  #endif
434  return status;
435  }
436 
437  /*FUNCTION**********************************************************************
438  *
439  * Function Name : CMP_DRV_GetInputFlags
440  * Description : Return all input change flags in <flags>.
441  * <flags> format : Flag_Ch7 Flag_Ch6 ... Flag_Ch0
442  * Implements : CMP_DRV_GetInputFlags_Activity
443  *
444  *END**************************************************************************/
445 status_t CMP_DRV_GetInputFlags(const uint32_t instance, cmp_ch_list_t *flags)
446 {
447  status_t status = STATUS_SUCCESS;
448  DEV_ASSERT(flags != NULL);
449  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
450  const CMP_Type* baseAddr = g_cmpBase[instance];
451 
452  uint32_t tmp = baseAddr->C2;
453  *flags = (cmp_ch_list_t)((tmp & (uint32_t)CMP_INPUT_FLAGS_MASK) >> CMP_INPUT_FLAGS_SHIFT);
454  return status;
455  }
456  /*FUNCTION**********************************************************************
457  *
458  * Function Name : CMP_DRV_ClearInputFlags
459  * Description : Clear all input change flags .
460  * Implements : CMP_DRV_ClearInputFlags_Activity
461  *
462  *END**************************************************************************/
463 status_t CMP_DRV_ClearInputFlags(const uint32_t instance)
464 {
465  status_t status = STATUS_SUCCESS;
466  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
467  CMP_Type* baseAddr = g_cmpBase[instance];
468 
469  uint32_t tmp = baseAddr->C2;
470  tmp |= (uint32_t)CMP_INPUT_FLAGS_MASK;
471  baseAddr->C2 = tmp;
472  #ifdef ERRATA_E9005
473  (void)baseAddr->C2;
474  #endif
475  return status;
476 }
477 /*FUNCTION**********************************************************************
478  *
479  * Function Name : CMP_DRV_GetInitConfigComparator
480  * Description : Return configuration structure with reset values for comparator features (functional mode, power mode,
481  * inverter, hysteresis, offset, filter sampling period and samples count).
482  * Implements : CMP_DRV_GetInitConfigComparator_Activity
483  *
484  *END**************************************************************************/
486 {
487  status_t status = STATUS_SUCCESS;
488  DEV_ASSERT(config != NULL);
490  config->dmaTriggerState = false;
491  config->mode = CMP_DISABLED;
492  config->filterSampleCount = 0U;
493  config->filterSamplePeriod = 0U;
494  config->powerMode = CMP_LOW_SPEED;
495  config->inverterState = CMP_NORMAL;
496  config->outputSelect = CMP_COUT;
497  config->pinState = CMP_UNAVAILABLE;
500  return status;
501 }
502 /*FUNCTION**********************************************************************
503  *
504  * Function Name : CMP_DRV_ConfigComparator
505  * Description : Configure only comparator features (functional mode, power mode,
506  * inverter, hysteresis, offset, filter sampling period and samples count).
507  * Implements : CMP_DRV_ConfigComparator_Activity
508  *
509  *END**************************************************************************/
510 status_t CMP_DRV_ConfigComparator(const uint32_t instance, const cmp_comparator_t *config)
511 {
512  status_t status = STATUS_SUCCESS;
513  DEV_ASSERT(config != NULL);
514  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
515  CMP_Type* base = g_cmpBase[instance];
516  CMP_SetDMATriggerState(base, config->dmaTriggerState );
517  CMP_SetOutputInterruptTrigger(base, config->outputInterruptTrigger);
518  CMP_SetFunctionalMode(base, config->mode, config->filterSampleCount, config->filterSamplePeriod);
519  CMP_SetFilterSamplePeriod(base, config->filterSampleCount );
520  CMP_SetFilterSampleCount(base, config->filterSamplePeriod);
521  CMP_SetPowerMode(base, config->powerMode);
522  CMP_SetInverterState(base, config->inverterState);
523  CMP_SetComparatorOutputSource(base, config->outputSelect);
524  CMP_SetOutputPinState(base, config->pinState);
525  CMP_SetOffset(base, config->offsetLevel);
526  CMP_SetHysteresis(base, config->hysteresisLevel);
527  return status;
528 }
529 /*FUNCTION**********************************************************************
530  *
531  * Function Name : CMP_DRV_GetComparator
532  * Description : Return configuration for comparator components from CMP module.
533  * Implements : CMP_DRV_GetComparatorConfig_Activity
534  *
535  *END**************************************************************************/
536 status_t CMP_DRV_GetComparatorConfig(const uint32_t instance, cmp_comparator_t *config)
537 {
538  status_t status = STATUS_SUCCESS;
539  DEV_ASSERT(config != NULL);
540  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
541  const CMP_Type* base = g_cmpBase[instance];
542  config->dmaTriggerState = CMP_GetDMATriggerState(base);
543  config->outputInterruptTrigger = CMP_GetOutputInterruptTrigger(base);
544  config->mode = CMP_GetFunctionalMode(base);
545  config->filterSampleCount = CMP_GetFilterSamplePeriod(base);
546  config->filterSamplePeriod = CMP_GetFilterSampleCount(base);
547  config->powerMode = CMP_GetPowerMode(base);
548  config->inverterState = CMP_GetInverterState(base);
549  config->outputSelect = CMP_GetComparatorOutputSource(base);
550  config->pinState = CMP_GetOutputPinState(base);
551  config->offsetLevel = CMP_GetOffset(base);
552  config->hysteresisLevel = CMP_GetHysteresis(base);
553  return status;
554 }
555 /******************************************************************************
556  * EOF
557  *****************************************************************************/
558 
#define CMP_C2_CH6F(x)
Definition: S32K142.h:1874
#define CMP_C2_FXMP(x)
Definition: S32K142.h:1886
status_t CMP_DRV_GetComparatorConfig(const uint32_t instance, cmp_comparator_t *config)
Return configuration for comparator from CMP module.
Definition: cmp_driver.c:536
cmp_ch_number_t fixedChannel
Definition: cmp_driver.h:240
#define CMP_C2_FXMXCH(x)
Definition: S32K142.h:1882
#define CMP_C1_INNSEL(x)
Definition: S32K142.h:1829
#define CMP_C0_FILTER_CNT(x)
Definition: S32K142.h:1716
#define CMP_C0_FPR(x)
Definition: S32K142.h:1748
uint8_t initializationDelay
Definition: cmp_driver.h:242
cmp_fixed_port_t fixedPort
Definition: cmp_driver.h:238
#define CMP_C1_CHN6(x)
Definition: S32K142.h:1821
status_t CMP_DRV_GetDACConfig(const uint32_t instance, cmp_dac_t *const config)
Return current configuration for DAC.
Definition: cmp_driver.c:256
status_t CMP_DRV_ConfigTriggerMode(const uint32_t instance, const cmp_trigger_mode_t *config)
Configure trigger mode.
Definition: cmp_driver.c:354
cmp_ch_number_t positiveInputMux
Definition: cmp_driver.h:210
#define CMP_C0_SE(x)
Definition: S32K142.h:1744
#define CMP_C2_NSAM(x)
Definition: S32K142.h:1846
#define CMP_BASE_PTRS
Definition: S32K142.h:1687
#define CMP_C0_IER(x)
Definition: S32K142.h:1768
#define CMP_C1_MSEL(x)
Definition: S32K142.h:1781
status_t CMP_DRV_GetInitTriggerMode(cmp_trigger_mode_t *config)
Get reset configuration for registers related with Trigger Mode.
Definition: cmp_driver.c:333
#define CMP_C1_DACEN(x)
Definition: S32K142.h:1793
static CMP_Type *const g_cmpBase[]
Definition: cmp_driver.c:61
#define CMP_C1_CHN1(x)
Definition: S32K142.h:1801
__IO uint32_t C1
Definition: S32K142.h:1671
cmp_anmux_t mux
Definition: cmp_driver.h:259
#define CMP_C1_PSEL(x)
Definition: S32K142.h:1785
status_t CMP_DRV_ConfigDAC(const uint32_t instance, const cmp_dac_t *config)
Configure only the DAC component.
Definition: cmp_driver.c:238
status_t CMP_DRV_GetInitConfigComparator(cmp_comparator_t *config)
Get reset configuration for registers related with comparator features.
Definition: cmp_driver.c:485
status_t CMP_DRV_GetTriggerModeConfig(const uint32_t instance, cmp_trigger_mode_t *const config)
Get current trigger mode configuration.
Definition: cmp_driver.c:377
#define CMP_C0_CFR(x)
Definition: S32K142.h:1760
Defines the analog mux.
Definition: cmp_driver.h:202
bool roundRobinInterruptState
Definition: cmp_driver.h:237
bool state
Definition: cmp_driver.h:225
Defines the trigger mode.
Definition: cmp_driver.h:234
status_t CMP_DRV_ClearInputFlags(const uint32_t instance)
Clear comparator input channels flags.
Definition: cmp_driver.c:463
#define DEV_ASSERT(x)
Definition: devassert.h:77
#define CMP_C0_IEF(x)
Definition: S32K142.h:1764
#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:400
uint8_t voltage
Definition: cmp_driver.h:224
status_t CMP_DRV_GetConfigAll(const uint32_t instance, cmp_module_t *const config)
Gets the current comparator configuration.
Definition: cmp_driver.c:180
#define CMP_C1_CHN7(x)
Definition: S32K142.h:1825
cmp_ch_list_t roundRobinChannelsState
Definition: cmp_driver.h:243
cmp_output_trigger_t
Comparator output interrupt configuration Implements : cmp_output_trigger_t_Class.
Definition: cmp_driver.h:127
#define CMP_C1_VRSEL(x)
Definition: S32K142.h:1789
uint8_t filterSamplePeriod
Definition: cmp_driver.h:178
Defines the comparator module configuration.
Definition: cmp_driver.h:256
#define CMP_C0_HYSTCTR(x)
Definition: S32K142.h:1708
#define CMP_C2_RRIE(x)
Definition: S32K142.h:1890
status_t CMP_DRV_ConfigMUX(const uint32_t instance, const cmp_anmux_t *config)
Configure only the MUX component.
Definition: cmp_driver.c:293
status_t CMP_DRV_GetInitConfigMUX(cmp_anmux_t *config)
Get reset configuration for registers related with MUX.
Definition: cmp_driver.c:275
status_t CMP_DRV_GetInputFlags(const uint32_t instance, cmp_ch_list_t *flags)
Gets input channels change flags.
Definition: cmp_driver.c:445
cmp_voltage_reference_t voltageReferenceSource
Definition: cmp_driver.h:222
status_t CMP_DRV_ConfigComparator(const uint32_t instance, const cmp_comparator_t *config)
Configure only comparator features.
Definition: cmp_driver.c:510
#define CMP_C1_INPSEL(x)
Definition: S32K142.h:1833
#define CMP_C0_OPE(x)
Definition: S32K142.h:1724
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:184
#define CMP_C1_CHN0(x)
Definition: S32K142.h:1797
status_t CMP_DRV_GetInitConfigAll(cmp_module_t *config)
Get reset configuration for all registers.
Definition: cmp_driver.c:99
#define CMP_C0_CFF_SHIFT
Definition: S32K142.h:1754
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:137
#define CMP_C2_RRE(x)
Definition: S32K142.h:1894
#define CMP_C0_CFR_SHIFT
Definition: S32K142.h:1758
#define CMP_C2_CH4F(x)
Definition: S32K142.h:1866
cmp_ch_number_t negativeInputMux
Definition: cmp_driver.h:211
#define CMP_C2_CH3F(x)
Definition: S32K142.h:1862
#define CMP_C2_ACOn(x)
Definition: S32K142.h:1838
#define CMP_C1_VOSEL(x)
Definition: S32K142.h:1777
cmp_port_mux_t positivePortMux
Definition: cmp_driver.h:204
#define CMP_INSTANCE_COUNT
Definition: S32K142.h:1676
uint8_t cmp_ch_list_t
Comparator channels list (1bit/channel) |------—|------—|--—|------—|------—| |CH7_state|CH6_sta...
Definition: cmp_driver.h:157
#define CMP_C0_COS(x)
Definition: S32K142.h:1728
#define CMP_C0_CFR_MASK
Definition: S32K142.h:1757
cmp_comparator_t comparator
Definition: cmp_driver.h:258
#define CMP_C2_CH0F(x)
Definition: S32K142.h:1850
#define CMP_C0_INVT(x)
Definition: S32K142.h:1732
cmp_mode_t mode
Definition: cmp_driver.h:177
cmp_dac_t dac
Definition: cmp_driver.h:260
cmp_output_select_t outputSelect
Definition: cmp_driver.h:186
#define CMP_C2_INITMOD(x)
Definition: S32K142.h:1842
#define CMP_C0_OFFSET(x)
Definition: S32K142.h:1712
cmp_offset_t offsetLevel
Definition: cmp_driver.h:188
#define CMP_C0_EN(x)
Definition: S32K142.h:1720
status_t CMP_DRV_GetInitConfigDAC(cmp_dac_t *config)
Get reset configuration for registers related with DAC.
Definition: cmp_driver.c:222
Defines the block configuration.
Definition: cmp_driver.h:170
#define CMP_C0_PMODE(x)
Definition: S32K142.h:1736
#define CMP_C1_CHN5(x)
Definition: S32K142.h:1817
cmp_hysteresis_t hysteresisLevel
Definition: cmp_driver.h:190
status_t CMP_DRV_ClearOutputFlags(const uint32_t instance)
Clear comparator output flags.
Definition: cmp_driver.c:418
#define CMP_C0_WE(x)
Definition: S32K142.h:1740
#define CMP_C2_CH1F(x)
Definition: S32K142.h:1854
uint8_t filterSampleCount
Definition: cmp_driver.h:179
__IO uint32_t C0
Definition: S32K142.h:1670
#define CMP_C1_CHN3(x)
Definition: S32K142.h:1809
#define CMP_C0_CFF_MASK
Definition: S32K142.h:1753
#define CMP_C2_CH7F(x)
Definition: S32K142.h:1878
#define CMP_INPUT_FLAGS_SHIFT
Definition: cmp_driver.h:34
cmp_trigger_mode_t triggerMode
Definition: cmp_driver.h:261
cmp_output_trigger_t outputInterruptTrigger
Definition: cmp_driver.h:173
#define CMP_C0_CFF(x)
Definition: S32K142.h:1756
#define CMP_C2_CH2F(x)
Definition: S32K142.h:1858
__IO uint32_t C2
Definition: S32K142.h:1672
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:313
Defines the DAC block.
Definition: cmp_driver.h:220
#define CMP_C1_CHN4(x)
Definition: S32K142.h:1813
cmp_ch_list_t programedState
Definition: cmp_driver.h:247
cmp_power_mode_t powerMode
Definition: cmp_driver.h:180
cmp_inverter_t inverterState
Definition: cmp_driver.h:182
#define CMP_C1_CHN2(x)
Definition: S32K142.h:1805
cmp_port_mux_t negativePortMux
Definition: cmp_driver.h:207
#define CMP_C0_DMAEN(x)
Definition: S32K142.h:1772
#define CMP_C2_CH5F(x)
Definition: S32K142.h:1870