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  */
33 #include "cmp_driver.h"
34 #include <stddef.h>
35 
36 /*******************************************************************************
37  * Variables
38  ******************************************************************************/
39 /* Table of base addresses for CMP instances. */
40 static CMP_Type * const g_cmpBase[] = CMP_BASE_PTRS;
41 /*FUNCTION**********************************************************************
42  *
43  * Function Name : CMP_DRV_Reset
44  * Description : This function set all CMP registers to reset values.
45  *
46  * Implements : CMP_DRV_Reset_Activity
47  *END**************************************************************************/
48 status_t CMP_DRV_Reset(const uint32_t instance)
49 {
50  status_t status = STATUS_SUCCESS;
51  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
52  CMP_Type* base = g_cmpBase[instance];
53  CMP_HAL_Init(base);
54  return status;
55 }
56 /*FUNCTION**********************************************************************
57  *
58  * Function Name : CMP_DRV_GetInitConfigAll
59  * Description : Return a configuration structure with reset values for all components
60  * from comparator module.
61  * Implements : CMP_DRV_GetInitConfigAll_Activity
62  *
63  *END**************************************************************************/
65 {
66  status_t status = STATUS_SUCCESS;
67  DEV_ASSERT(config != NULL);
68  (config->comparator).outputInterruptTrigger = CMP_NO_EVENT;
69  (config->comparator).mode = CMP_DISABLED;
70  (config->comparator).filterSampleCount = 0U;
71  (config->comparator).filterSamplePeriod = 0U;
72  (config->comparator).powerMode = CMP_LOW_SPEED;
73  (config->comparator).inverterState = CMP_NORMAL;
74  (config->comparator).outputSelect = CMP_COUT;
75  (config->comparator).pinState = CMP_UNAVAILABLE;
76  (config->comparator).offsetLevel = CMP_LEVEL_OFFSET_0;
77  (config->comparator).hysteresisLevel = CMP_LEVEL_HYS_0;
78  (config->dac).state = false;
79  (config->dac).voltageReferenceSource = CMP_VIN1;
80  (config->dac).voltage = 0U;
81  (config->mux).negativePortMux = CMP_DAC;
82  (config->mux).positivePortMux = CMP_DAC;
83  (config->mux).negativeInputMux = 0U;
84  (config->mux).positiveInputMux = 0U;
85  (config->triggerMode).roundRobinState = false;
86  (config->triggerMode).roundRobinInterruptState = false;
87  (config->triggerMode).fixedPort = CMP_PLUS_FIXED;
88  (config->triggerMode).fixedChannel = 0U;
89  (config->triggerMode).samples = 0U;
90  (config->triggerMode).roundRobinChannelsState = 0U;
91  (config->triggerMode).programedState = 0U;
92  (config->triggerMode).initializationDelay = 0U;
93  return status;
94 }
95 /*FUNCTION**********************************************************************
96  *
97  * Function Name : CMP_DRV_Init
98  * Description : Configure all components from comparator module.
99  *
100  * Implements : CMP_DRV_Init_Activity
101  *END**************************************************************************/
102 status_t CMP_DRV_Init(const uint32_t instance, const cmp_module_t* const config)
103 {
104  status_t status = STATUS_SUCCESS;
105  DEV_ASSERT(config != NULL);
106  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
107  CMP_Type* base = g_cmpBase[instance];
108  CMP_HAL_SetDMATriggerState(base, (config->comparator).dmaTriggerState );
109  CMP_HAL_SetOutputInterruptTrigger(base, (config->comparator).outputInterruptTrigger);
110  CMP_HAL_SetFunctionalMode(base, (config->comparator).mode, (config->comparator).filterSampleCount, (config->comparator).filterSamplePeriod);
111  CMP_HAL_SetPowerMode(base, (config->comparator).powerMode);
112  CMP_HAL_SetInverterState(base, (config->comparator).inverterState);
113  CMP_HAL_SetComparatorOutputSource(base, (config->comparator).outputSelect);
114  CMP_HAL_SetOutputPinState(base, (config->comparator).pinState);
115  CMP_HAL_SetHysteresis(base, (config->comparator).hysteresisLevel);
116  CMP_HAL_SetOffset(base, (config->comparator).offsetLevel);
117  CMP_HAL_SetDACState(base, (config->dac).state);
118  CMP_HAL_SetVoltageReference(base, (config->dac).voltageReferenceSource);
119  CMP_HAL_SetVoltage(base, (config->dac).voltage);
120  CMP_HAL_SetNegativePortInput(base, (config->mux).negativePortMux);
121  CMP_HAL_SetPositivePortInput(base, (config->mux).positivePortMux);
122  CMP_HAL_SetMinusMUXControl(base, (config->mux).negativeInputMux);
123  CMP_HAL_SetPlusMuxControl(base, (config->mux).positiveInputMux);
124  CMP_HAL_SetFixedPort(base, (config->triggerMode).fixedPort);
125  CMP_HAL_SetFixedChannel(base, (config->triggerMode).fixedChannel);
126  CMP_HAL_SetRoundRobinSamplesNumber(base, (config->triggerMode).samples);
127  CMP_HAL_SetInitDelay(base, (config->triggerMode).initializationDelay);
128  CMP_HAL_SetRoundRobinChannels(base, (config->triggerMode).roundRobinChannelsState);
129  CMP_HAL_SetPresetState(base, (config->triggerMode).programedState);
130  CMP_HAL_SetRoundRobinInterruptState(base, (config->triggerMode).roundRobinInterruptState);
131  CMP_HAL_SetRoundRobinState(base, (config->triggerMode).roundRobinState);
132  /* Clear all flags*/
135  return status;
136 }
137 /*FUNCTION**********************************************************************
138  *
139  * Function Name : CMP_DRV_GetConfigAll
140  * Description : This function returns the configuration for all components
141  * from comparator module.
142  * Implements : CMP_DRV_GetConfigAll_Activity
143  *
144  *END**************************************************************************/
145 status_t CMP_DRV_GetConfigAll(const uint32_t instance, cmp_module_t* const config)
146 {
147  status_t status = STATUS_SUCCESS;
148  DEV_ASSERT(config != NULL);
149  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
150  const CMP_Type* base = g_cmpBase[instance];
151  (config->comparator).dmaTriggerState = CMP_HAL_GetDMATriggerState(base);
152  (config->comparator).outputInterruptTrigger = CMP_HAL_GetOutputInterruptTrigger(base);
153  (config->comparator).mode = CMP_HAL_GetFunctionalMode(base);
154  (config->comparator).filterSampleCount = CMP_HAL_GetFilterSampleCount(base);
155  (config->comparator).filterSamplePeriod = CMP_HAL_GetFilterSamplePeriod(base);
156  (config->comparator).powerMode = CMP_HAL_GetPowerMode(base);
157  (config->comparator).inverterState = CMP_HAL_GetInverterState(base);
158  (config->comparator).outputSelect = CMP_HAL_GetComparatorOutputSource(base);
159  (config->comparator).pinState = CMP_HAL_GetOutputPinState(base);
160  (config->comparator).offsetLevel = CMP_HAL_GetOffset(base);
161  (config->comparator).hysteresisLevel = CMP_HAL_GetHysteresis(base);
162  (config->dac).state = CMP_HAL_GetDACState(base);
163  (config->dac).voltageReferenceSource = CMP_HAL_GetVoltageReference(base);
164  (config->dac).voltage = CMP_HAL_GetVoltage(base);
165  (config->mux).negativePortMux = CMP_HAL_GetNegativePortInput(base);
166  (config->mux).positivePortMux = CMP_HAL_GetPositivePortInput(base);
167  (config->mux).negativeInputMux = CMP_HAL_GetMinusMUXControl(base);
168  (config->mux).positiveInputMux = CMP_HAL_GetPlusMUXControl(base);
169  (config->triggerMode).roundRobinState = CMP_HAL_GetRoundRobinState(base);
170  (config->triggerMode).roundRobinInterruptState = CMP_HAL_GetRoundRobinInterruptState(base);
171  (config->triggerMode).fixedPort = CMP_HAL_GetFixedPort(base);
172  (config->triggerMode).fixedChannel = CMP_HAL_GetFixedChannel(base);
173  (config->triggerMode).samples = CMP_HAL_GetRoundRobinSamplesNumber(base);
174  (config->triggerMode).roundRobinChannelsState = CMP_HAL_GetRoundRobinChannels(base);
175  (config->triggerMode).programedState = CMP_HAL_GetLastComparisonResult(base);
176  (config->triggerMode).initializationDelay = CMP_HAL_GetInitDelay(base);
177  return status;
178 }
179 /*FUNCTION**********************************************************************
180  *
181  * Function Name : CMP_DRV_GetInitConfigDAC
182  * Description : Return configuration structure with reset values for DAC
183  * component from comparator module.
184  * Implements : CMP_DRV_GetInitConfigDAC_Activity
185  *
186  *END**************************************************************************/
188 {
189  status_t status = STATUS_SUCCESS;
190  DEV_ASSERT(config != NULL);
191  config->state = false;
193  config->voltage = 0U;
194  return status;
195 }
196 /*FUNCTION**********************************************************************
197  *
198  * Function Name : CMP_DRV_ConfigDAC
199  * Description : Configure only DAC component from comparator module.
200  * Implements : CMP_DRV_ConfigDAC_Activity
201  *
202  *END**************************************************************************/
203 status_t CMP_DRV_ConfigDAC(const uint32_t instance, const cmp_dac_t* config)
204 {
205  status_t status = STATUS_SUCCESS;
206  DEV_ASSERT(config != NULL);
207  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
208  CMP_Type* base = g_cmpBase[instance];
209  CMP_HAL_SetDACState(base, config->state);
211  CMP_HAL_SetVoltage(base, config->voltage);
212  return status;
213 }
214 /*FUNCTION**********************************************************************
215  *
216  * Function Name : CMP_DRV_GetDAC
217  * Description : Return configuration for DAC component from comparator module.
218  * Implements : CMP_DRV_GetDACConfig_Activity
219  *
220  *END**************************************************************************/
221 status_t CMP_DRV_GetDACConfig(const uint32_t instance, cmp_dac_t* const config)
222 {
223  status_t status = STATUS_SUCCESS;
224  DEV_ASSERT(config != NULL);
225  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
226  const CMP_Type* base = g_cmpBase[instance];
227  config->state = CMP_HAL_GetDACState(base);
229  config->voltage = CMP_HAL_GetVoltage(base);
230  return status;
231 }
232 /*FUNCTION**********************************************************************
233  *
234  * Function Name : CMP_DRV_GetInitConfigMUX
235  * Description : Return configuration structure with reset values for
236  * the MUX component which select source signals for comparator ports.
237  * Implements : CMP_DRV_GetInitConfigMUX_Activity
238  *
239  *END**************************************************************************/
241 {
242  status_t status = STATUS_SUCCESS;
243  DEV_ASSERT(config != NULL);
244  config->negativePortMux = CMP_DAC;
245  config->positivePortMux = CMP_DAC;
246  config->negativeInputMux = 0U;
247  config->positiveInputMux = 0U;
248  return status;
249 }
250 /*FUNCTION**********************************************************************
251  *
252  * Function Name : CMP_DRV_ConfigMUX
253  * Description : Configure only MUX component from comparator module to select
254  * source signals for comparator ports.
255  * Implements : CMP_DRV_ConfigMUX_Activity
256  *
257  *END**************************************************************************/
258 status_t CMP_DRV_ConfigMUX(const uint32_t instance, const cmp_anmux_t* config)
259 {
260  status_t status = STATUS_SUCCESS;
261  DEV_ASSERT(config != NULL);
262  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
263  CMP_Type* base = g_cmpBase[instance];
268  return status;
269 }
270 /*FUNCTION**********************************************************************
271  *
272  * Function Name : CMP_DRV_GetMUX
273  * Description : Return configuration for the MUX component which select
274  * source signals for comparator ports.
275  * Implements : CMP_DRV_GetMUXConfig_Activity
276  *
277  *END**************************************************************************/
278 status_t CMP_DRV_GetMUXConfig(const uint32_t instance, cmp_anmux_t* const config)
279 {
280  status_t status = STATUS_SUCCESS;
281  DEV_ASSERT(config != NULL);
282  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
283  const CMP_Type* base = g_cmpBase[instance];
288  return status;
289 }
290 /*FUNCTION**********************************************************************
291  *
292  * Function Name : CMP_DRV_GetInitTriggerMode
293  * Description : Return configuration structure with reset values for Trigger Mode
294  * from comparator module.
295  * Implements : CMP_DRV_GetInitTriggerMode_Activity
296  *
297  *END**************************************************************************/
299 {
300  status_t status = STATUS_SUCCESS;
301  DEV_ASSERT(config != NULL);
302  config->roundRobinState = false;
303  config->roundRobinInterruptState = false;
304  config->fixedPort = CMP_PLUS_FIXED;
305  config->fixedChannel = 0U;
306  config->samples = 0U;
307  config->roundRobinChannelsState = 0U;
308  config->programedState = 0U;
309  config->initializationDelay = 0U;
310  return status;
311 }
312 /*FUNCTION**********************************************************************
313  *
314  * Function Name : CMP_DRV_ConfigTriggerMode
315  * Description : Configure comparator in trigger mode.
316  * Implements : CMP_DRV_ConfigTriggerMode_Activity
317  *
318  *END**************************************************************************/
319 status_t CMP_DRV_ConfigTriggerMode(const uint32_t instance, const cmp_trigger_mode_t* config)
320 {
321  status_t status = STATUS_SUCCESS;
322  DEV_ASSERT(config != NULL);
323  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
324  CMP_Type* base = g_cmpBase[instance];
327  CMP_HAL_SetFixedPort(base, config->fixedPort);
328  CMP_HAL_SetFixedChannel(base, config->fixedChannel);
332  CMP_HAL_SetPresetState(base, config->programedState);
333  return status;
334 }
335 /*FUNCTION**********************************************************************
336  *
337  * Function Name : CMP_DRV_GetTriggerMode
338  * Description : Return configuration for the trigger mode.
339  * Implements : CMP_DRV_GetTriggerModeConfig_Activity
340  *
341  *END**************************************************************************/
342 status_t CMP_DRV_GetTriggerModeConfig(const uint32_t instance, cmp_trigger_mode_t* const config)
343 {
344  status_t status = STATUS_SUCCESS;
345  DEV_ASSERT(config != NULL);
346  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
347  const CMP_Type* base = g_cmpBase[instance];
350  config->fixedPort = CMP_HAL_GetFixedPort(base);
351  config->fixedChannel = CMP_HAL_GetFixedChannel(base);
356  return status;
357 }
358 /*FUNCTION**********************************************************************
359  *
360  * Function Name : CMP_DRV_GetOutputFlags
361  * Description : Return in <flags> comparator output flags(rising and falling edge on output).
362  * Implements : CMP_DRV_GetOutputFlags_Activity
363  *
364  *END**************************************************************************/
365 status_t CMP_DRV_GetOutputFlags(const uint32_t instance, cmp_output_trigger_t *flags)
366 {
367  status_t status = STATUS_SUCCESS;
368  DEV_ASSERT(flags != NULL);
369  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
370  const CMP_Type* base = g_cmpBase[instance];
371  *flags = CMP_HAL_GetOutputEvent(base);
372  return status;
373 }
374 /*FUNCTION**********************************************************************
375  *
376  * Function Name : CMP_DRV_ClearOutputFlags
377  * Description : Clear comparator output flags(rising and falling edge on output).
378  * Implements : CMP_DRV_ClearOutputFlags_Activity
379  *
380  *END**************************************************************************/
381 status_t CMP_DRV_ClearOutputFlags(const uint32_t instance)
382 {
383  status_t status = STATUS_SUCCESS;
384  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
385  CMP_Type* base = g_cmpBase[instance];
387  return status;
388  }
389 
390  /*FUNCTION**********************************************************************
391  *
392  * Function Name : CMP_DRV_GetInputFlags
393  * Description : Return all input change flags in <flags>.
394  * <flags> format : Flag_Ch7 Flag_Ch6 ... Flag_Ch0
395  * Implements : CMP_DRV_GetInputFlags_Activity
396  *
397  *END**************************************************************************/
398 status_t CMP_DRV_GetInputFlags(const uint32_t instance, cmp_ch_list_t *flags)
399 {
400  status_t status = STATUS_SUCCESS;
401  DEV_ASSERT(flags != NULL);
402  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
403  const CMP_Type* base = g_cmpBase[instance];
404  *flags = CMP_HAL_GetInputChangedFlags(base);
405  return status;
406  }
407  /*FUNCTION**********************************************************************
408  *
409  * Function Name : CMP_DRV_ClearInputFlags
410  * Description : Clear all input change flags .
411  * Implements : CMP_DRV_ClearInputFlags_Activity
412  *
413  *END**************************************************************************/
414 status_t CMP_DRV_ClearInputFlags(const uint32_t instance)
415 {
416  status_t status = STATUS_SUCCESS;
417  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
418  CMP_Type* base = g_cmpBase[instance];
420  return status;
421 }
422 /*FUNCTION**********************************************************************
423  *
424  * Function Name : CMP_DRV_GetInitConfigComparator
425  * Description : Return configuration structure with reset values for comparator features (functional mode, power mode,
426  * inverter, hysteresis, offset, filter sampling period and samples count).
427  * Implements : CMP_DRV_GetInitConfigComparator_Activity
428  *
429  *END**************************************************************************/
431 {
432  status_t status = STATUS_SUCCESS;
433  DEV_ASSERT(config != NULL);
435  config->dmaTriggerState = false;
436  config->mode = CMP_DISABLED;
437  config->filterSampleCount = 0U;
438  config->filterSamplePeriod = 0U;
439  config->powerMode = CMP_LOW_SPEED;
440  config->inverterState = CMP_NORMAL;
441  config->outputSelect = CMP_COUT;
442  config->pinState = CMP_UNAVAILABLE;
445  return status;
446 }
447 /*FUNCTION**********************************************************************
448  *
449  * Function Name : CMP_DRV_ConfigComparator
450  * Description : Configure only comparator features (functional mode, power mode,
451  * inverter, hysteresis, offset, filter sampling period and samples count).
452  * Implements : CMP_DRV_ConfigComparator_Activity
453  *
454  *END**************************************************************************/
455 status_t CMP_DRV_ConfigComparator(const uint32_t instance, const cmp_comparator_t *config)
456 {
457  status_t status = STATUS_SUCCESS;
458  DEV_ASSERT(config != NULL);
459  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
460  CMP_Type* base = g_cmpBase[instance];
463  CMP_HAL_SetFunctionalMode(base, config->mode, config->filterSampleCount, config->filterSamplePeriod);
466  CMP_HAL_SetPowerMode(base, config->powerMode);
469  CMP_HAL_SetOutputPinState(base, config->pinState);
470  CMP_HAL_SetOffset(base, config->offsetLevel);
471  CMP_HAL_SetHysteresis(base, config->hysteresisLevel);
472  return status;
473 }
474 /*FUNCTION**********************************************************************
475  *
476  * Function Name : CMP_DRV_GetComparator
477  * Description : Return configuration for comparator components from CMP module.
478  * Implements : CMP_DRV_GetComparatorConfig_Activity
479  *
480  *END**************************************************************************/
481 status_t CMP_DRV_GetComparatorConfig(const uint32_t instance, cmp_comparator_t *config)
482 {
483  status_t status = STATUS_SUCCESS;
484  DEV_ASSERT(config != NULL);
485  DEV_ASSERT(instance < CMP_INSTANCE_COUNT);
486  const CMP_Type* base = g_cmpBase[instance];
489  config->mode = CMP_HAL_GetFunctionalMode(base);
492  config->powerMode = CMP_HAL_GetPowerMode(base);
493  config->inverterState = CMP_HAL_GetInverterState(base);
495  config->pinState = CMP_HAL_GetOutputPinState(base);
496  config->offsetLevel = CMP_HAL_GetOffset(base);
497  config->hysteresisLevel = CMP_HAL_GetHysteresis(base);
498  return status;
499 }
500 /******************************************************************************
501  * EOF
502  *****************************************************************************/
503 
static cmp_hysteresis_t CMP_HAL_GetHysteresis(const CMP_Type *baseAddr)
Return the current hysteresis level.
Definition: cmp_hal.h:699
static void CMP_HAL_SetInitDelay(CMP_Type *baseAddr, uint8_t to_set)
Set the comparator and DAC initialization delay.
Definition: cmp_hal.h:1178
status_t CMP_DRV_GetComparatorConfig(const uint32_t instance, cmp_comparator_t *config)
Return configuration for comparator from CMP module.
Definition: cmp_driver.c:481
static cmp_ch_number_t CMP_HAL_GetFixedChannel(const CMP_Type *baseAddr)
Return which channel is selected for fixed mux port(as fixed reference)
Definition: cmp_hal.h:1076
cmp_ch_number_t fixedChannel
Definition: cmp_driver.h:111
static cmp_ch_list_t CMP_HAL_GetInputChangedFlags(const CMP_Type *baseAddr)
Return all input changed flags.
Definition: cmp_hal.h:1107
static void CMP_HAL_SetInverterState(CMP_Type *baseAddr, cmp_inverter_t to_set)
Configure the comparator output inverter mode.
Definition: cmp_hal.h:542
uint8_t initializationDelay
Definition: cmp_driver.h:113
cmp_fixed_port_t fixedPort
Definition: cmp_driver.h:109
status_t CMP_DRV_GetDACConfig(const uint32_t instance, cmp_dac_t *const config)
Return current configuration for DAC.
Definition: cmp_driver.c:221
static cmp_output_trigger_t CMP_HAL_GetOutputEvent(const CMP_Type *baseAddr)
Return type of event occurred at the comparator output.
Definition: cmp_hal.h:317
static void CMP_HAL_SetFilterSamplePeriod(CMP_Type *baseAddr, uint8_t to_set)
Set the filter sample period(clock cycles)
Definition: cmp_hal.h:431
static void CMP_HAL_SetOutputInterruptTrigger(CMP_Type *baseAddr, cmp_output_trigger_t to_set)
Set the comparator output interrupts source configuration(none, rising edge, falling edge or both edg...
Definition: cmp_hal.h:299
static void CMP_HAL_SetVoltageReference(CMP_Type *baseAddr, cmp_voltage_reference_t to_set)
Set the voltage reference.
Definition: cmp_hal.h:900
status_t CMP_DRV_ConfigTriggerMode(const uint32_t instance, const cmp_trigger_mode_t *config)
Configure trigger mode.
Definition: cmp_driver.c:319
cmp_ch_number_t positiveInputMux
Definition: cmp_driver.h:81
static void CMP_HAL_SetComparatorOutputSource(CMP_Type *baseAddr, cmp_output_select_t to_set)
Select the comparator output signal source.
Definition: cmp_hal.h:569
static void CMP_HAL_SetDMATriggerState(CMP_Type *baseAddr, bool to_set)
Configure the DMA transfer trigger.
Definition: cmp_hal.h:266
static void CMP_HAL_SetPositivePortInput(CMP_Type *baseAddr, cmp_port_mux_t to_set)
Set the source for positive port of the comparator.
Definition: cmp_hal.h:777
#define CMP_BASE_PTRS
Definition: S32K144.h:1773
cmp_output_trigger_t
Comparator output interrupt configuration Implements : cmp_output_trigger_t_Class.
Definition: cmp_hal.h:150
static void CMP_HAL_SetDACState(CMP_Type *baseAddr, bool to_set)
Set the DAC state (enabled/disabled)
Definition: cmp_hal.h:873
status_t CMP_DRV_GetInitTriggerMode(cmp_trigger_mode_t *config)
Get reset configuration for registers related with Trigger Mode.
Definition: cmp_driver.c:298
static cmp_ch_number_t CMP_HAL_GetMinusMUXControl(const CMP_Type *baseAddr)
Determine which input is selected for the minus mux.
Definition: cmp_hal.h:939
static void CMP_HAL_SetRoundRobinState(CMP_Type *baseAddr, bool to_set)
Set the round robin operation state.
Definition: cmp_hal.h:1011
static void CMP_HAL_ClearOutputEvent(CMP_Type *baseAddr)
Clear all output flags.
Definition: cmp_hal.h:330
static CMP_Type *const g_cmpBase[]
Definition: cmp_driver.c:40
void CMP_HAL_SetFunctionalMode(CMP_Type *baseAddr, cmp_mode_t mode, uint8_t filter_sample_count, uint8_t filter_sample_period)
Sets the comparator functional mode (mode, filter count, filter period)
Definition: cmp_hal.c:81
cmp_anmux_t mux
Definition: cmp_driver.h:130
static void CMP_HAL_SetPowerMode(CMP_Type *baseAddr, cmp_power_mode_t to_set)
Set the power mode.
Definition: cmp_hal.h:515
static uint8_t CMP_HAL_GetVoltage(const CMP_Type *baseAddr)
Return the current output voltage level(0-255)
Definition: cmp_hal.h:967
static void CMP_HAL_SetVoltage(CMP_Type *baseAddr, uint8_t to_set)
Set the output voltage level.
Definition: cmp_hal.h:981
status_t CMP_DRV_ConfigDAC(const uint32_t instance, const cmp_dac_t *config)
Configure only the DAC component.
Definition: cmp_driver.c:203
cmp_mode_t CMP_HAL_GetFunctionalMode(const CMP_Type *baseAddr)
Gets the comparator functional mode. If you want to get filter count and filter period please use CMP...
Definition: cmp_hal.c:150
static cmp_voltage_reference_t CMP_HAL_GetVoltageReference(const CMP_Type *baseAddr)
Return the current voltage reference.
Definition: cmp_hal.h:886
status_t CMP_DRV_GetInitConfigComparator(cmp_comparator_t *config)
Get reset configuration for registers related with comparator features.
Definition: cmp_driver.c:430
status_t CMP_DRV_GetTriggerModeConfig(const uint32_t instance, cmp_trigger_mode_t *const config)
Get current trigger mode configuration.
Definition: cmp_driver.c:342
Defines the analog mux.
Definition: cmp_driver.h:73
bool roundRobinInterruptState
Definition: cmp_driver.h:108
bool state
Definition: cmp_driver.h:96
Defines the trigger mode.
Definition: cmp_driver.h:105
status_t CMP_DRV_ClearInputFlags(const uint32_t instance)
Clear comparator input channels flags.
Definition: cmp_driver.c:414
#define DEV_ASSERT(x)
Definition: devassert.h:78
uint8_t cmp_ch_list_t
Comparator channels list (1bit/channel) |------—|------—|--—|------—|------—| |CH7_state|CH6_sta...
Definition: cmp_hal.h:180
static cmp_offset_t CMP_HAL_GetOffset(const CMP_Type *baseAddr)
Return the current offset level.
Definition: cmp_hal.h:667
status_t CMP_DRV_GetOutputFlags(const uint32_t instance, cmp_output_trigger_t *flags)
Get comparator output flags.
Definition: cmp_driver.c:365
uint8_t voltage
Definition: cmp_driver.h:95
static cmp_ch_list_t CMP_HAL_GetRoundRobinChannels(const CMP_Type *baseAddr)
Return which channels are used for round-robin checker.
Definition: cmp_hal.h:826
status_t CMP_DRV_GetConfigAll(const uint32_t instance, cmp_module_t *const config)
Gets the current comparator configuration.
Definition: cmp_driver.c:145
static cmp_output_enable_t CMP_HAL_GetOutputPinState(const CMP_Type *baseAddr)
Verify if the comparator output state(available/not available in a packaged pin)
Definition: cmp_hal.h:582
static void CMP_HAL_SetPresetState(CMP_Type *baseAddr, cmp_ch_list_t to_set)
Defines the pre-set state of input channels.
Definition: cmp_hal.h:1206
cmp_ch_list_t roundRobinChannelsState
Definition: cmp_driver.h:114
uint8_t filterSamplePeriod
Definition: cmp_driver.h:49
Defines the comparator module configuration.
Definition: cmp_driver.h:127
static cmp_inverter_t CMP_HAL_GetInverterState(const CMP_Type *baseAddr)
Return the current comparator output inverter.
Definition: cmp_hal.h:528
status_t CMP_DRV_ConfigMUX(const uint32_t instance, const cmp_anmux_t *config)
Configure only the MUX component.
Definition: cmp_driver.c:258
static cmp_port_mux_t CMP_HAL_GetNegativePortInput(const CMP_Type *baseAddr)
Return the current source for negative port of the comparator.
Definition: cmp_hal.h:793
status_t CMP_DRV_GetInitConfigMUX(cmp_anmux_t *config)
Get reset configuration for registers related with MUX.
Definition: cmp_driver.c:240
status_t CMP_DRV_GetInputFlags(const uint32_t instance, cmp_ch_list_t *flags)
Gets input channels change flags.
Definition: cmp_driver.c:398
cmp_voltage_reference_t voltageReferenceSource
Definition: cmp_driver.h:93
status_t CMP_DRV_ConfigComparator(const uint32_t instance, const cmp_comparator_t *config)
Configure only comparator features.
Definition: cmp_driver.c:455
static void CMP_HAL_ClearInputChangedFlags(CMP_Type *baseAddr)
Clear all input changed flags.
Definition: cmp_hal.h:1120
static cmp_ch_list_t CMP_HAL_GetLastComparisonResult(const CMP_Type *baseAddr)
Return last input comparison results for all channels.
Definition: cmp_hal.h:1192
static uint8_t CMP_HAL_GetInitDelay(const CMP_Type *baseAddr)
Return the comparator and DAC initialization delay.
Definition: cmp_hal.h:1164
static cmp_port_mux_t CMP_HAL_GetPositivePortInput(const CMP_Type *baseAddr)
Return the current source for positive port of the comparator.
Definition: cmp_hal.h:761
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
Definition: status.h:31
status_t CMP_DRV_Reset(const uint32_t instance)
Reset all registers.
Definition: cmp_driver.c:48
cmp_output_enable_t pinState
Definition: cmp_driver.h:55
static void CMP_HAL_SetOffset(CMP_Type *baseAddr, cmp_offset_t to_set)
Set the offset level.
Definition: cmp_hal.h:681
static void CMP_HAL_SetFixedChannel(CMP_Type *baseAddr, cmp_ch_number_t to_set)
Set which channel is used as the fixed reference input for the fixed mux port.
Definition: cmp_hal.h:1090
status_t CMP_DRV_GetInitConfigAll(cmp_module_t *config)
Get reset configuration for all registers.
Definition: cmp_driver.c:64
static uint8_t CMP_HAL_GetFilterSamplePeriod(const CMP_Type *baseAddr)
Return the sample period for filter(clock cycles)
Definition: cmp_hal.h:417
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:102
static bool CMP_HAL_GetDMATriggerState(const CMP_Type *baseAddr)
Verify if the DMA transfer trigger is enabled.
Definition: cmp_hal.h:252
static uint8_t CMP_HAL_GetFilterSampleCount(const CMP_Type *baseAddr)
Return the number of consecutive samples that must agree prior to the comparator output filter accept...
Definition: cmp_hal.h:635
cmp_ch_number_t negativeInputMux
Definition: cmp_driver.h:82
static void CMP_HAL_SetRoundRobinSamplesNumber(CMP_Type *baseAddr, uint8_t to_set)
Set how many round-robin clock cycles takes sampling.
Definition: cmp_hal.h:1150
static cmp_output_trigger_t CMP_HAL_GetOutputInterruptTrigger(const CMP_Type *baseAddr)
Return the comparator output interrupts source configuration(none, rising edge, falling edge or both ...
Definition: cmp_hal.h:281
static cmp_power_mode_t CMP_HAL_GetPowerMode(const CMP_Type *baseAddr)
Return the current power mode.
Definition: cmp_hal.h:502
static void CMP_HAL_SetRoundRobinChannels(CMP_Type *baseAddr, cmp_ch_list_t to_set)
Set which channels are use for round-robin checker.
Definition: cmp_hal.h:843
cmp_port_mux_t positivePortMux
Definition: cmp_driver.h:75
static uint8_t CMP_HAL_GetRoundRobinSamplesNumber(const CMP_Type *baseAddr)
Return how many round-robin clock cycles takes sampling.
Definition: cmp_hal.h:1136
#define CMP_INSTANCE_COUNT
Definition: S32K144.h:1762
void CMP_HAL_Init(CMP_Type *baseAddr)
Initializes the comparator registers with reset values.
Definition: cmp_hal.c:42
static void CMP_HAL_SetMinusMUXControl(CMP_Type *baseAddr, cmp_ch_number_t to_set)
Select input for the minus mux.
Definition: cmp_hal.h:953
cmp_comparator_t comparator
Definition: cmp_driver.h:129
static void CMP_HAL_SetRoundRobinInterruptState(CMP_Type *baseAddr, bool to_set)
Set the round robin interrupt state.
Definition: cmp_hal.h:1038
static void CMP_HAL_SetOutputPinState(CMP_Type *baseAddr, cmp_output_enable_t to_set)
Set the comparator output pin state(available/not available in a packaged pin)
Definition: cmp_hal.h:596
cmp_mode_t mode
Definition: cmp_driver.h:48
cmp_dac_t dac
Definition: cmp_driver.h:131
cmp_output_select_t outputSelect
Definition: cmp_driver.h:57
static void CMP_HAL_SetPlusMuxControl(CMP_Type *baseAddr, cmp_ch_number_t to_set)
Select input for the plus mux.
Definition: cmp_hal.h:925
static cmp_ch_number_t CMP_HAL_GetPlusMUXControl(const CMP_Type *baseAddr)
Determine which input is selected for the plus mux.
Definition: cmp_hal.h:911
cmp_offset_t offsetLevel
Definition: cmp_driver.h:59
status_t CMP_DRV_GetInitConfigDAC(cmp_dac_t *config)
Get reset configuration for registers related with DAC.
Definition: cmp_driver.c:187
Defines the block configuration.
Definition: cmp_driver.h:41
static void CMP_HAL_SetFilterSampleCount(CMP_Type *baseAddr, uint8_t to_set)
Set the number of consecutive samples that must agree prior to the comparator output filter accepting...
Definition: cmp_hal.h:650
cmp_hysteresis_t hysteresisLevel
Definition: cmp_driver.h:61
status_t CMP_DRV_ClearOutputFlags(const uint32_t instance)
Clear comparator output flags.
Definition: cmp_driver.c:381
static void CMP_HAL_SetHysteresis(CMP_Type *baseAddr, cmp_hysteresis_t to_set)
Set the hysteresis level.
Definition: cmp_hal.h:717
uint8_t filterSampleCount
Definition: cmp_driver.h:50
static void CMP_HAL_SetNegativePortInput(CMP_Type *baseAddr, cmp_port_mux_t to_set)
Set the source for negative port of the comparator.
Definition: cmp_hal.h:809
static void CMP_HAL_SetFixedPort(CMP_Type *baseAddr, cmp_fixed_port_t to_set)
Set the fixed port for round-robin operation.
Definition: cmp_hal.h:1063
cmp_trigger_mode_t triggerMode
Definition: cmp_driver.h:132
cmp_output_trigger_t outputInterruptTrigger
Definition: cmp_driver.h:44
static cmp_fixed_port_t CMP_HAL_GetFixedPort(const CMP_Type *baseAddr)
Return the port fixed for round-robin operation.
Definition: cmp_hal.h:1049
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:278
Defines the DAC block.
Definition: cmp_driver.h:91
cmp_ch_list_t programedState
Definition: cmp_driver.h:118
cmp_power_mode_t powerMode
Definition: cmp_driver.h:51
cmp_inverter_t inverterState
Definition: cmp_driver.h:53
static cmp_output_select_t CMP_HAL_GetComparatorOutputSource(const CMP_Type *baseAddr)
Return the current comparator output selected.
Definition: cmp_hal.h:555
cmp_port_mux_t negativePortMux
Definition: cmp_driver.h:78
static bool CMP_HAL_GetRoundRobinState(const CMP_Type *baseAddr)
Verify if the round robin operation is enabled.
Definition: cmp_hal.h:997
bool dmaTriggerState
Definition: cmp_driver.h:43
static bool CMP_HAL_GetRoundRobinInterruptState(const CMP_Type *baseAddr)
Verify if the round robin interrupt is enabled.
Definition: cmp_hal.h:1024
static bool CMP_HAL_GetDACState(const CMP_Type *baseAddr)
Verify if the DAC is enabled.
Definition: cmp_hal.h:859