adc.h

 
/******************************************************************************
 *
 * Copyright (C) 2022-2023 Maxim Integrated Products, Inc. (now owned by 
 * Analog Devices, Inc.),
 * Copyright (C) 2023-2024 Analog Devices, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 ******************************************************************************/
 
/* Define to prevent redundant inclusion */
#ifndef LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32680_ADC_H_
#define LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32680_ADC_H_
 
/* **** Includes **** */
#include <stdint.h>
#include "adc_regs.h"
#include "mcr_regs.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
// Macros to select ADC channels
#define MXC_V_ADC_CTRL_ADC_CHSEL_AIN0 ((uint32_t)(0x00000000UL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_AIN1 ((uint32_t)(0x00000001UL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_AIN2 ((uint32_t)(0x00000002UL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_AIN3 ((uint32_t)(0x00000003UL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_AIN4 ((uint32_t)(0x00000004UL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_AIN5 ((uint32_t)(0x00000005UL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_AIN6 ((uint32_t)(0x00000006UL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_AIN7 ((uint32_t)(0x00000007UL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_VCOREA ((uint32_t)(0x00000008UL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_VCOREB ((uint32_t)(0x00000009UL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_VRXOUT ((uint32_t)(0x0000000AUL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_VTXOUT ((uint32_t)(0x0000000BUL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_VDDA ((uint32_t)(0x0000000CUL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_VDDB ((uint32_t)(0x0000000DUL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_VDDI0 ((uint32_t)(0x0000000EUL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_VDDI0H ((uint32_t)(0x0000000FUL))
#define MXC_V_ADC_CTRL_ADC_CHSEL_VREGI ((uint32_t)(0x00000010UL))
 
/***************************************************************************************************************
                                    DATA STRUCTURES FOR ADC INITIALIZATION
***************************************************************************************************************/
typedef enum {
    MXC_ADC_CH_0 = MXC_V_ADC_CTRL_ADC_CHSEL_AIN0, // Select Channel 0
    MXC_ADC_CH_1 = MXC_V_ADC_CTRL_ADC_CHSEL_AIN1, // Select Channel 1
    MXC_ADC_CH_2 = MXC_V_ADC_CTRL_ADC_CHSEL_AIN2, // Select Channel 2
    MXC_ADC_CH_3 = MXC_V_ADC_CTRL_ADC_CHSEL_AIN3, // Select Channel 3
    MXC_ADC_CH_4 = MXC_V_ADC_CTRL_ADC_CHSEL_AIN4, // Channel 0 divided by 5
    MXC_ADC_CH_5 = MXC_V_ADC_CTRL_ADC_CHSEL_AIN5, // Channel 1 divided by 5
    MXC_ADC_CH_6 = MXC_V_ADC_CTRL_ADC_CHSEL_AIN6, // VDDB divided by 4
    MXC_ADC_CH_7 = MXC_V_ADC_CTRL_ADC_CHSEL_AIN7, // VDD18 input select
    MXC_ADC_CH_VCOREA = MXC_V_ADC_CTRL_ADC_CHSEL_VCOREA, // VDD12 input select
    MXC_ADC_CH_VCOREB = MXC_V_ADC_CTRL_ADC_CHSEL_VCOREB,
    MXC_ADC_CH_VRXOUT = MXC_V_ADC_CTRL_ADC_CHSEL_VRXOUT, // VRTC divided by 2
    MXC_ADC_CH_VTXOUT = MXC_V_ADC_CTRL_ADC_CHSEL_VTXOUT, // TMON input select
    MXC_ADC_CH_VDDA = MXC_V_ADC_CTRL_ADC_CHSEL_VDDA,
    MXC_ADC_CH_VDDB = MXC_V_ADC_CTRL_ADC_CHSEL_VDDB,
    MXC_ADC_CH_VDDIO = MXC_V_ADC_CTRL_ADC_CHSEL_VDDI0,
    MXC_ADC_CH_VDDIOH = MXC_V_ADC_CTRL_ADC_CHSEL_VDDI0H,
    MXC_ADC_CH_VREGI = MXC_V_ADC_CTRL_ADC_CHSEL_VREGI,
} mxc_adc_chsel_t;
 
#if 0
typedef enum {
    MXC_ADC_COMP_0          = MXC_F_MCR_AINCOMP_AINCOMP0PD,
    MXC_ADC_COMP_1          = MXC_F_MCR_AINCOMP_AINCOMP1PD,
    MXC_ADC_COMP_2          = MXC_F_MCR_AINCOMP_AINCOMP2PD,
    MXC_ADC_COMP_3          = MXC_F_MCR_AINCOMP_AINCOMP3PD,
    MXC_ADC_COMP_HYST_0     = 1 << MXC_F_MCR_AINCOMP_AINCOMPHYST_POS,    //Refer to the V HYST specification in the data sheet electrical characteristics
    // for the values corresponding to this field value.
    MXC_ADC_COMP_HYST_1     = 2 << MXC_F_MCR_AINCOMP_AINCOMPHYST_POS,   //Refer to the V HYST specification in the data sheet electrical characteristics
    // for the values corresponding to this field value.
} mxc_adc_comp_t;
#endif
 
typedef enum {
    MXC_ADC_MONITOR_0,
    MXC_ADC_MONITOR_1,
    MXC_ADC_MONITOR_2,
    MXC_ADC_MONITOR_3,
} mxc_adc_monitor_t;
 
typedef enum {
    MXC_ADC_SCALE_2X, // ADC Scale by 2x (this scales ADC Reference by 1/2)
    MXC_ADC_SCALE_1, // ADC Scale by 1x (no scaling)
    MXC_ADC_SCALE_2, // ADC Scale by 1/2
    MXC_ADC_SCALE_3, // ADC Scale by 1/3
    MXC_ADC_SCALE_4, // ADC Scale by 1/4
    MXC_ADC_SCALE_6, // ADC Scale by 1/6 (this uses 1/3 and an additional 1/2 scaling)
    MXC_ADC_SCALE_8, // ADC Scale by 1/8 (this uses 1/4 and an additional 1/2 scaling)
} mxc_adc_scale_t;
 
typedef enum {
    MXC_ADC_REF_INT, // Selects internal bandgap reference
    MXC_ADC_REF_EXT, // Selects external reference pins
} mxc_adc_ref_t;
 
// Callback used when a conversion event is complete
typedef void (*mxc_adc_complete_cb_t)(void *req, int error);
 
// Callback used when a monitor detects that a channel has reached a limit
typedef void (*mxc_adc_monitor_cb_t)(void *req, int error);
 
// Used to set up a monitor to watch a channel
typedef struct {
    mxc_adc_monitor_t monitor; // Monitor to use
    mxc_adc_scale_t scale; // Channel scale to use (if external channel)
    mxc_adc_chsel_t channel; // Channel to use
    int lowThreshold; // Low Threshold for monitor (RAW ADC counts)
    int highThreshold; // High Threshold for monitor (RAW ADC counts)
    mxc_adc_monitor_cb_t callback; // Function to call when the channel crosses threshold
} mxc_adc_monitor_req_t;
 
typedef struct {
    mxc_adc_chsel_t channel; // Channel to use
    mxc_adc_scale_t scale; // Channel scale to use (if external channel)
    int rawADCValue; // Result of the conversion
    mxc_adc_complete_cb_t callback; // Function to call when callback is complete
} mxc_adc_conversion_req_t;
 
int MXC_ADC_Init(void);
 
int MXC_ADC_Shutdown(void);
 
int MXC_ADC_Busy(void);
 
void MXC_ADC_EnableInt(uint32_t flags);
 
void MXC_ADC_DisableInt(uint32_t flags);
 
int MXC_ADC_GetFlags(void);
 
void MXC_ADC_ClearFlags(uint32_t flags);
 
int MXC_ADC_SetConversionSpeed(uint32_t hz);
 
int MXC_ADC_GetConversionSpeed(void);
 
void MXC_ADC_SetDataAlignment(int msbJustify);
 
// Internal channels are approx. known and have fixed scaling
// Externals channels can be scaled with standard scaling (1-4x)
// Or by using a separate 1/2 input scale, or a 1/2 ref scale (total range 0.5-8x)
void MXC_ADC_SetExtScale(mxc_adc_scale_t scale);
 
void MXC_ADC_RefSelect(mxc_adc_ref_t ref);
 
void MXC_ADC_EnableMonitor(mxc_adc_monitor_t monitors);
 
void MXC_ADC_DisableMonitor(mxc_adc_monitor_t monitors);
 
void MXC_ADC_SetMonitorHighThreshold(mxc_adc_monitor_t monitor, uint32_t threshold);
 
int MXC_ADC_GetMonitorHighThreshold(mxc_adc_monitor_t monitor);
 
void MXC_ADC_SetMonitorLowThreshold(mxc_adc_monitor_t monitor, uint32_t threshold);
 
int MXC_ADC_GetMonitorLowThreshold(mxc_adc_monitor_t monitor);
 
void MXC_ADC_SetMonitorChannel(mxc_adc_monitor_t monitor, mxc_adc_chsel_t channel);
 
int MXC_ADC_GetMonitorChannel(mxc_adc_monitor_t monitor);
 
// Monitor a channel and call the callback if it hits a limit
void MXC_ADC_EnableMonitorAsync(mxc_adc_monitor_t monitor, mxc_adc_monitor_cb_t callback);
 
void MXC_ADC_DisableMonitorAsync(mxc_adc_monitor_t monitor);
 
int MXC_ADC_StartConversion(mxc_adc_chsel_t channel);
 
int MXC_ADC_StartConversionAsync(mxc_adc_chsel_t channel, mxc_adc_complete_cb_t callback);
 
int MXC_ADC_Handler(void);
 
int MXC_ADC_Convert(mxc_adc_conversion_req_t *req);
 
int MXC_ADC_ConvertAsync(mxc_adc_conversion_req_t *req);
 
void MXC_ADC_Monitor(mxc_adc_monitor_req_t req);
 
void MXC_ADC_MonitorAsync(mxc_adc_monitor_req_t req);
 
void MXC_ADC_EnableComparators(uint32_t mask);
 
void MXC_ADC_DisableComparators(uint32_t mask);
 
int MXC_ADC_GetData(uint16_t *outdata);
#ifdef __cplusplus
}
#endif
 
#endif // LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32680_ADC_H_