adc1.h

Go to the documentation of this file.

 
/*
© [2024] Microchip Technology Inc. and its subsidiaries.
 
    Subject to your compliance with these terms, you may use Microchip 
    software and any derivatives exclusively with Microchip products. 
    You are responsible for complying with 3rd party license terms  
    applicable to your use of 3rd party software (including open source  
    software) that may accompany Microchip software. SOFTWARE IS ?AS IS.? 
    NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS 
    SOFTWARE, INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT,  
    MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT 
    WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, 
    INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY 
    KIND WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF 
    MICROCHIP HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE 
    FORESEEABLE. TO THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP?S 
    TOTAL LIABILITY ON ALL CLAIMS RELATED TO THE SOFTWARE WILL NOT 
    EXCEED AMOUNT OF FEES, IF ANY, YOU PAID DIRECTLY TO MICROCHIP FOR 
    THIS SOFTWARE.
*/
 
#ifndef ADC1_H
#define ADC1_H
 
// Section: Included Files
 
#include <xc.h>
#include <stdbool.h>
#include <stdint.h>
#include "adc_types.h"
#include "adc_interface.h"
#ifdef __cplusplus  //Provide C++ Compatibility
 
    extern "C" {
 
#endif
 
// Section: Data Types
 
#define ADC1_SCAN_MODE_SELECTED true
 
#define ADC1_RESOLUTION 12
 
// Section: Data Type Definitions
 
extern const struct ADC_INTERFACE ADC1;
 
 
// Section: Driver Interface Functions
 
void ADC1_Initialize (void);
 
void ADC1_Deinitialize(void);
 
inline static void ADC1_Enable(void)
{
   ADCON1Lbits.ADON = 1;
}
 
inline static void ADC1_Disable(void)
{
   ADCON1Lbits.ADON = 0;
}
 
inline static void ADC1_SoftwareTriggerEnable(void)
{
   ADCON3Lbits.SWCTRG = 1;
}
 
inline static void ADC1_SoftwareTriggerDisable(void)
{
   ADCON3Lbits.SWCTRG = 0;
}
 
inline static void ADC1_ChannelSelect( enum ADC_CHANNEL channel )
{
    //This function does not have any implementation since 
    //Shared channels are selected from UI.
    //Dedicated channels are selected from UI.
    
    (void)channel;
}
 
inline static uint16_t ADC1_ConversionResultGet( enum ADC_CHANNEL channel )
{
    uint16_t result = 0x0U;
 
    switch(channel)
    {
        case VSEC:
                result = ADCBUF2;
                break;
        case IPRI_CT:
                result = ADCBUF7;
                break;
        case VPRI:
                result = ADCBUF10;
                break;
        case TEMP:
                result = ADCBUF14;
                break;
        case VRAIL_5V:
                result = ADCBUF19;
                break;
        case ISEC_CT:
                result = ADCBUF0;
                break;
        case ISEC_AVG:
                result = ADCBUF1;
                break;
        default:
                break;
    }
    return result;
}
 
inline static bool ADC1_IsConversionComplete(enum ADC_CHANNEL channel)
{
    bool status = false;
 
    switch(channel)
    {
        case VSEC:
                status = ADSTATLbits.AN2RDY;
                break;
        case IPRI_CT:
                status = ADSTATLbits.AN7RDY;
                break;
        case VPRI:
                status = ADSTATLbits.AN10RDY;
                break;
        case TEMP:
                status = ADSTATLbits.AN14RDY;
                break;
        case VRAIL_5V:
                status = ADSTATHbits.AN19RDY;
                break;
        case ISEC_CT:
                status = ADSTATLbits.AN0RDY;
                break;
        case ISEC_AVG:
                status = ADSTATLbits.AN1RDY;
                break;
        default:
                break;
    }
 
    return status;
}
 
inline static void ADC1_ResolutionSet(enum ADC_RESOLUTION_TYPE resolution)
{
   ADCORE0Hbits.RES = resolution;
   ADCORE1Hbits.RES = resolution;
   ADCON1Hbits.SHRRES = resolution;
}
 
inline static void ADC1_InterruptEnable(void)
{
    IEC5bits.ADCIE = 1;
}
 
inline static void ADC1_InterruptDisable(void)
{
    IEC5bits.ADCIE = 0;
}
 
inline static void ADC1_InterruptFlagClear(void)
{
    IFS5bits.ADCIF = 0;
}
 
inline static void ADC1_InterruptPrioritySet( uint16_t priorityValue )
{
    IPC22bits.ADCIP = (uint16_t)0x7 & priorityValue;
}
 
void ADC1_CommonCallbackRegister(void(*callback)(void));
 
void ADC1_CommonCallback(void);
 
 
void ADC1_Tasks(void);
 
inline static void ADC1_IndividualChannelInterruptEnable(enum ADC_CHANNEL channel)
{
    switch(channel)
    {
        case VSEC:
                IEC5bits.ADCAN2IE = 1;
                ADIELbits.IE2 = 1;
                break;
        case IPRI_CT:
                IEC6bits.ADCAN7IE = 1;
                ADIELbits.IE7 = 1;
                break;
        case VPRI:
                IEC6bits.ADCAN10IE = 1;
                ADIELbits.IE10 = 1;
                break;
        case TEMP:
                IEC6bits.ADCAN14IE = 1;
                ADIELbits.IE14 = 1;
                break;
        case VRAIL_5V:
                IEC6bits.ADCAN19IE = 1;
                ADIEHbits.IE19 = 1;
                break;
        case ISEC_CT:
                IEC5bits.ADCAN0IE = 1;
                ADIELbits.IE0 = 1;
                break;
        case ISEC_AVG:
                IEC5bits.ADCAN1IE = 1;
                ADIELbits.IE1 = 1;
                break;
        default:
                break;
    }
}
 
inline static void ADC1_IndividualChannelInterruptDisable(enum ADC_CHANNEL channel)
{
    switch(channel)
    {
        case VSEC:
                IEC5bits.ADCAN2IE = 0;
                ADIELbits.IE2 = 0;
                break;
        case IPRI_CT:
                IEC6bits.ADCAN7IE = 0;
                ADIELbits.IE7 = 0;
                break;
        case VPRI:
                IEC6bits.ADCAN10IE = 0;
                ADIELbits.IE10 = 0;
                break;
        case TEMP:
                IEC6bits.ADCAN14IE = 0;
                ADIELbits.IE14 = 0;
                break;
        case VRAIL_5V:
                IEC6bits.ADCAN19IE = 0;
                ADIEHbits.IE19 = 0;
                break;
        case ISEC_CT:
                IEC5bits.ADCAN0IE = 0;
                ADIELbits.IE0 = 0;
                break;
        case ISEC_AVG:
                IEC5bits.ADCAN1IE = 0;
                ADIELbits.IE1 = 0;
                break;
        default:
                break;
    }
}
 
inline static void ADC1_IndividualChannelInterruptFlagClear(enum ADC_CHANNEL channel)
{
    switch(channel)
    {
        case VSEC:
                IFS5bits.ADCAN2IF = 0;
                break;
        case IPRI_CT:
                IFS6bits.ADCAN7IF = 0;
                break;
        case VPRI:
                IFS6bits.ADCAN10IF = 0;
                break;
        case TEMP:
                IFS6bits.ADCAN14IF = 0;
                break;
        case VRAIL_5V:
                IFS6bits.ADCAN19IF = 0;
                break;
        case ISEC_CT:
                IFS5bits.ADCAN0IF = 0;
                break;
        case ISEC_AVG:
                IFS5bits.ADCAN1IF = 0;
                break;
        default:
                break;
    }
}
 
inline static void ADC1_IndividualChannelInterruptPrioritySet(enum ADC_CHANNEL channel, enum INTERRUPT_PRIORITY priorityValue)
{
    switch(channel)
    {
        case VSEC:
                IPC23bits.ADCAN2IP = priorityValue;
                break;
        case IPRI_CT:
                IPC24bits.ADCAN7IP = priorityValue;
                break;
        case VPRI:
                IPC25bits.ADCAN10IP = priorityValue;
                break;
        case TEMP:
                IPC26bits.ADCAN14IP = priorityValue;
                break;
        case VRAIL_5V:
                IPC27bits.ADCAN19IP = priorityValue;
                break;
        case ISEC_CT:
                IPC22bits.ADCAN0IP = priorityValue;
                break;
        case ISEC_AVG:
                IPC23bits.ADCAN1IP = priorityValue;
                break;
        default:
                break;
    }
}
 
void ADC1_ChannelCallbackRegister(void(*callback)(enum ADC_CHANNEL channel, uint16_t adcVal));
 
void ADC1_ChannelCallback(enum ADC_CHANNEL channel, uint16_t adcVal);
 
 
void ADC1_ComparatorCallbackRegister(void(*callback)(enum ADC_CMP comparator));
 
void ADC1_ComparatorCallback(enum ADC_CMP comparator);
 
 
void ADC1_ChannelTasks(enum ADC_CHANNEL channel);
 
 
// Section: Interface functions: Dedicated Core
 
void ADC1_CorePowerEnable(enum ADC_DEDICATED_CORE core);
 
 
void ADC1_SharedCorePowerEnable(void);
 
 
void ADC1_PWMTriggerSourceSet(enum ADC_CHANNEL channel, enum ADC_PWM_INSTANCE pwmInstance, enum ADC_PWM_TRIGGERS triggerNumber);
 
#ifdef __cplusplus  // Provide C++ Compatibility
 
    }
 
#endif
 
#endif //_ADC1_H