/* --COPYRIGHT--,BSD
 * Copyright (c) 2014, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * --/COPYRIGHT--*/
//*****************************************************************************
//
// esi.h - Driver for the ESI Module.
//
//*****************************************************************************

//*****************************************************************************
//
//! \addtogroup esi_api
//! @{
//
//*****************************************************************************

#include "inc/hw_regaccess.h"
#include "inc/hw_memmap.h"

#ifdef __MSP430_HAS_ESI__
#include "esi.h"

#include <assert.h>

// Uncomment for finding lower peak of the lower half cycle.
// This required to set ESI comparator output as inverted
#define INVERTED

static uint16_t measureESIOSC(void);
static void FindDAC(uint8_t selected_channel,
                    uint8_t software_trigger);

const ESI_AFE1_InitParams ESI_AFE1_INITPARAMS_DEFAULT =
{ESI_EXCITATION_CIRCUIT_DISABLED,
 ESI_SAMPLE_HOLD_DISABLED,
 ESI_MID_VOLTAGE_GENERATOR_DISABLED,
 ESI_SAMPLE_HOLD_VSS_TO_ESIVSS,
 ESI_INVERTER_FOR_AFE1_DISABLE};

const ESI_AFE2_InitParams ESI_AFE2_INITPARAMS_DEFAULT = {
    ESI_AFE2_INPUT_SELECT_CHx,
    ESI_INVERTER_FOR_AFE2_DISABLE,
    ESI_TSM_COMPARATOR_CONTROL_AFE2_DISABLE,
    ESI_TSM_DAC_CONTROL_AFE2_DISABLE
};

const ESI_TSM_InitParams ESI_TSM_INITPARAMS_DEFAULT = { ESI_TSM_SMCLK_DIV_1,
                                                        ESI_TSM_ACLK_DIV_1,
                                                        ESI_TSM_START_TRIGGER_DIV_2,
                                                        ESI_TSM_REPEAT_NEW_TRIGGER,
                                                        ESI_TSM_STOP_SEQUENCE,
                                                        ESI_TSM_HIGH_FREQ_CLK_FUNCTION_ON};

const ESI_PSM_InitParams ESI_PSM_INITPARAMS_DEFAULT = { ESI_PSM_Q6_DISABLE,
                                                        ESI_PSM_Q7_TRIGGER_DISABLE,
                                                        ESI_PSM_CNT0_DISABLE,
                                                        ESI_PSM_CNT0_RESET,
                                                        ESI_PSM_CNT1_DISABLE,
                                                        ESI_PSM_CNT1_RESET,
                                                        ESI_PSM_CNT2_DISABLE,
                                                        ESI_PSM_CNT2_RESET,
                                                        ESI_PSM_S3_SELECT,
                                                        ESI_PSM_TEST4_IS_Q2,};

//*****************************************************************************
//
//! Get ESI PSM Counter 0 Value
//!
//! This function reads the ESI Counter 0 register
//!
//! \return  Counter value
//
//*****************************************************************************
uint16_t ESI_getCounter0(void)
{
    return (ESICNT0);
}

//*****************************************************************************
//
//! Get ESI PSM Counter 1 Value
//!
//! This function reads the ESI Counter1 register
//!
//! \return Counter value
//
//*****************************************************************************
uint16_t ESI_getCounter1(void)
{
    return (ESICNT1);
}

//*****************************************************************************
//
//! Get ESI PSM Counter 2 Value
//!
//! This function reads the ESI Counter2 register
//!
//! \return Counter value
//
//*****************************************************************************
uint16_t ESI_getCounter2(void)
{
    return (ESICNT2);
}

//*****************************************************************************
//
//! Get ESI PSM Oscillator Counter Value
//!
//! This function reads the ESI Oscillator Counter register
//!
//! \return Counter value
//
//*****************************************************************************
uint16_t ESI_getOscCounter(void)
{
    return (ESICNT3);
}

//*****************************************************************************
//
//! Initializes the ESI analog front end AFE1
//!
//! \param params is ESI_AFE1_InitParams struct
//!
//! This functions initializes the ESI analog front end AFE1.
//!
//! \return None
//
//*****************************************************************************

void ESI_AFE1_init(ESI_AFE1_InitParams *params)
{
    // Unset the AFE1 bits
    ESIAFE &= ~(ESITEN + ESISH + ESIVCC2 + ESIVSS + ESICACI3 + ESICISEL +
                ESICA1X + ESICA1INV);
    ESIAFE |=
        params->excitationCircuitSelect +
        params->sampleAndHoldSelect +
        params->midVoltageGeneratorSelect +
        params->sampleAndHoldVSSConnect +
        params->inverterSelectOutputAFE1
    ;

    switch(params->inputSelectAFE1)
    {
    case ESI_AFE1_INPUT_SELECT_CHx:
        break;
    case ESI_AFE1_INPUT_SELECT_CIx:
        ESIAFE |= ESICA1X;
        break;
    case ESI_AFE1_INPUT_SELECT_CI3:
        ESIAFE |= ESICA1X;
        ESIAFE &= ~ESICISEL;
        ESIAFE |= ESICACI3;
        break;
    case ESI_AFE1_INPUT_SELECT_CI:
        ESIAFE |= ESICA1X;
        ESIAFE |= ESICISEL;
        break;
    default:
        break;
    }
}

//*****************************************************************************
//
//! Initializes the ESI analog front end - AFE2
//!
//! \param params is ESI_AFE2_InitParams struct
//!
//! This functions initializes the ESI analog front end AFE2
//!
//! \return None
//
//*****************************************************************************

void ESI_AFE2_init(ESI_AFE2_InitParams *params)
{
    // Unset the AFE2 bits
    ESIAFE &= ~(ESICA2X + ESICA2INV + ESICA2EN + ESIDAC2EN);

    ESIAFE |=
        params->inputSelectAFE2 +
        params->inverterSelectOutputAFE2 +
        params->tsmControlComparatorAFE2 +
        params->tsmControlDacAFE2
    ;
}

//*****************************************************************************
//
//! Reads the latched comparator outputs form the AFEs
//!
//! \param channelSelect. Valid values are
//!                 ESI_AFE1_CHANNEL0_SELECT
//!                 ESI_AFE1_CHANNEL1_SELECT
//!                 ESI_AFE1_CHANNEL2_SELECT
//!                 ESI_AFE1_CHANNEL3_SELECT
//!                 ESI_AFE2_CHANNEL0_SELECT
//!                 ESI_AFE2_CHANNEL1_SELECT
//!                 ESI_AFE2_CHANNEL2_SELECT
//!                 ESI_AFE2_CHANNEL3_SELECT
//!                 ESI_AFE1_TEST_CHANNEL0_SELECT
//!                 ESI_AFE1_TEST_CHANNEL1_SELECT
//!
//! This function gets the ESIPPU register to get latched output values of the
//! comparator outputs for AFE1 and AFE2
//!
//! \return Valid values are
//!                 ESI_AFE_OUTPUT_LOW
//!                 ESI_AFE_OUTPUT_HIGH
//
//*****************************************************************************
uint16_t ESI_getLatchedComparatorOutput(uint16_t channelSelect)
{
    uint16_t result;

    result = ESIPPU;

    return (result &= channelSelect);
}

//*****************************************************************************
//
//! Initializes the TSM
//!
//! \param params is ESI_TSM_InitParams struct
//!
//! This function initializes the TSM.
//!
//! \return None
//
//*****************************************************************************

void ESI_TSM_init(ESI_TSM_InitParams *params)
{
    ESITSM =
        params->smclkDivider +
        params->aclkDivider +
        params->startTriggerAclkDivider +
        params->repeatMode +
        params->startTriggerSelection +
        params->tsmFunctionSelection
    ;
}

//*****************************************************************************
//
//! Clear TSM entries
//!
//! This function clears all TSM entries
//!
//! \return None
//
//*****************************************************************************
void ESI_TSM_clearTable(void)
{
    uint16_t *pTsm, i;

    // Clear TSM Table (for testing only. not neccessary in real application)
    pTsm = (uint16_t *)&ESITSM0;
    for(i = 0; i < 32; i++)
    {
        *pTsm++ = 0x0200;
    }
}

//*****************************************************************************
//
//! Copy TSM entries
//!
//! This function copies all TSM entries
//!
//! \return None
//
//*****************************************************************************
void ESI_TSM_copyTable(uint16_t* tsmTable,
                       uint16_t size)
{
    uint16_t *pt_tsmTable;
    uint16_t i;

    // Copy the TSM_Table into ESI TSM registers
    // Destination pointer
    pt_tsmTable = (uint16_t *)&ESITSM0;
    // Divided by 2 because of unsigned integer (2bytes)
    i = size / 2;

    do
    {
        *pt_tsmTable++ = *tsmTable++;
    }
    while(--i);
}

//*****************************************************************************
//
//! TSM trigger using software
//!
//! This function starts a software initiated TSM sequence
//!
//! \return None
//
//*****************************************************************************
void ESI_TSM_softwareTrigger(void)
{
    ESITSM |= ESISTART;
}

//*****************************************************************************
//
//! TSM trigger using software
//!
//! This function starts a software initiated TSM sequence
//!
//! \return ESIREATx bits from selected stateRegNum
//
//*****************************************************************************
uint8_t ESI_TSM_getTSMStateDuration(uint8_t stateRegNum)
{
    volatile uint16_t* stateRegBase = (volatile uint16_t*)&ESITSM0;

    return((*(stateRegBase + stateRegNum) & 0xf800) >> 11);
}

//*****************************************************************************
//
//! TSM trigger using software
//!
//! This function starts a software initiated TSM sequence
//!
//! \return ESIREATx bits from selected stateRegNum
//
//*****************************************************************************
void ESI_TSM_setTSMStateDuration(uint8_t stateRegNum,
                                 uint8_t duration)
{
    assert(stateRegNum <= ESI_TSM_STATE_REG_31);
    assert(duration <= ESI_TSM_STATE_DURATION_MAX);

    volatile uint16_t* stateRegBase = (volatile uint16_t*)&ESITSM0;

    *(stateRegBase + stateRegNum) &= ~0xF800;

    *(stateRegBase + stateRegNum) |= (duration << 11);
}

//*****************************************************************************
//
//! Initialize Processing State Machine
//
//! \param params is ESI_PSM_InitParams struct
//!
//! This function initializes the PSM registers.
//!
//! \return None
//
//*****************************************************************************
void ESI_PSM_init(ESI_PSM_InitParams *params)
{
    ESIPSM =
        params->Q6Select +
        params->Q7TriggerSelect +
        params->count0Select +
        params->count0Reset +
        params->count1Select +
        params->count1Reset +
        params->count2Select +
        params->count2Reset +
        params->V2Select +
        params->TEST4Select
    ;
}

//*****************************************************************************
//
//! Clear PSM entries
//!
//! This function clears all PSM entries
//!
//! \return None
//
//*****************************************************************************
void ESI_PSM_clearTable(void)
{
    uint8_t *pPsm, i;

    // Clear TSM Table (for testing only. not neccessary in real application)
    pPsm = (uint8_t *)&ESIRAM0;
    for(i = 0; i < 128; i++)
    {
        *pPsm++ = 0x0;
    }
}

//*****************************************************************************
//
//! Copy PSM entries
//!
//! This function copies all PSM entries
//!
//! \return None
//
//*****************************************************************************
void ESI_PSM_copyTable(uint8_t* psmTable,
                       uint8_t size)
{
    uint8_t *pt_psmTable;
    uint8_t i;

    assert(size <= 128);

    // Copy the TSM_Table into ESI TSM registers
    pt_psmTable = (uint8_t *)&ESIRAM0;                                  // Destination pointer
    i = size;

    do
    {
        *pt_psmTable++ = *psmTable++;
    }
    while(--i);
}

//*****************************************************************************
//
//! Reset PSM counters
//!
//! \param counterToReset is the counter that needs t be reset
//!
//! This function resets the PSM counters
//!
//! \return None
//
//*****************************************************************************
void ESI_PSM_resetCounter(uint16_t counterToReset)
{
    ESIPSM |= counterToReset;
}

//*****************************************************************************
//
//! Enables the internal Oscillator
//!
//!
//! This function enables the high frequency internal oscillator
//!
//! \return None
//
//*****************************************************************************
void ESI_enableInternalOscillator(void)
{
    ESIOSC |= ESIHFSEL;
}

//*****************************************************************************
//
//! Disables the internal Oscillator
//!
//!
//! This function disables the high frequency internal oscillator
//!
//! \return None
//
//*****************************************************************************
void ESI_disableInternalOscillator(void)
{
    ESIOSC &= ~ESIHFSEL;
}

//*****************************************************************************
//
//! Connects comparator output to timerA input
//!
//! \param counterToReset ESI_TIMERA_INPUT_TSM_COMPOUT or
//!                       ESI_TIMERA_INPUT_TSM_PPUSRC
//!
//! This function connects the chosen comparator output to TimerA
//!
//! \return None
//
//*****************************************************************************
void ESI_timerAInputSelect(uint16_t select)
{
    ESICTL |= select;
}

//*****************************************************************************
//
//! Connects psm source to comparator output
//!
//! \param sourceNum PSM_S1_SOURCE, PSM_S2_SOURCE  or PSM_S3_SOURCE
//! \param sourceSelect can have the following values
//!         ESI_PSM_SOURCE_IS_ESIOUT0
//!         ESI_PSM_SOURCE_IS_ESIOUT1
//!         ESI_PSM_SOURCE_IS_ESIOUT2
//!         ESI_PSM_SOURCE_IS_ESIOUT3
//!         ESI_PSM_SOURCE_IS_ESIOUT4
//!         ESI_PSM_SOURCE_IS_ESIOUT5
//!         ESI_PSM_SOURCE_IS_ESIOUT6
//!         ESI_PSM_SOURCE_IS_ESIOUT7
//!
//! This function connects the chosen comparator output to TimerA
//!
//! \return None
//
//*****************************************************************************
void ESI_psmSourceSelect(uint16_t sourceNum,
                         uint16_t sourceSelect)
{
    switch(sourceNum)
    {
    case PSM_S1_SOURCE:
        ESICTL &= ~(ESIS1SEL0 | ESIS1SEL1 | ESIS1SEL2);
        ESICTL |= (sourceSelect << 7);
        break;
    case PSM_S2_SOURCE:
        ESICTL &= ~(ESIS2SEL0 | ESIS2SEL1 | ESIS2SEL2);
        ESICTL |= (sourceSelect << 10);
        break;
    case PSM_S3_SOURCE:
        ESICTL &= ~(ESIS3SEL0 | ESIS3SEL1 | ESIS3SEL2);
        ESICTL |= (sourceSelect << 13);
        break;
    default:
        break;
    }
}

//*****************************************************************************
//
//! Connects testChannel0 to comparator input
//!
//! \param sourceSelect can have the following values
//!         ESI_TEST_CHANNEL0_SOURCE_IS_CH0_CI0
//!         ESI_TEST_CHANNEL0_SOURCE_IS_CH1_CI1
//!         ESI_TEST_CHANNEL0_SOURCE_IS_CH2_CI2
//!         ESI_TEST_CHANNEL0_SOURCE_IS_CH3_CI3
//!
//! This function connects the chosen comparator input to the test channel0
//!
//! \return None
//
//*****************************************************************************
void ESI_testChannel0SourceSelect(uint16_t sourceSelect)
{
    ESICTL &= ~(ESI_TEST_CHANNEL0_SOURCE_IS_CH3_CI3);
    ESICTL |= sourceSelect;
}

//*****************************************************************************
//
//! Connects testChannel1to comparator input
//!
//! \param sourceSelect can have the following values
//!         ESI_TEST_CHANNEL1_SOURCE_IS_CH0_CI0
//!         ESI_TEST_CHANNEL1_SOURCE_IS_CH1_CI1
//!         ESI_TEST_CHANNEL1_SOURCE_IS_CH2_CI2
//!         ESI_TEST_CHANNEL1_SOURCE_IS_CH3_CI3
//!
//! This function connects the chosen comparator input to the test channel1
//!
//! \return None
//
//*****************************************************************************
void ESI_testChannel1SourceSelect(uint16_t sourceSelect)
{
    ESICTL &= ~(ESI_TEST_CHANNEL1_SOURCE_IS_CH3_CI3);
    ESICTL |= sourceSelect;
}

//*****************************************************************************
//
//! Enable ESI peripheral
//!
//! \return None
//
//*****************************************************************************
void ESI_enable(void)
{
    ESICTL |= ESIEN;
}

//*****************************************************************************
//
//! Disable ESI peripheral
//!
//! \return None
//
//*****************************************************************************
void ESI_disable(void)
{
    ESICTL &= ~ESIEN;
}

//*****************************************************************************
//
//! Start calibration on ESI internal Oscillator
//!
//! This function starts calibration of internal osciallator. After calling this
//! function the user and use ESI_adjustInternalOscFreq() to adjust the freq. of
//! the oscillator.
//!
//! \return None
//
//*****************************************************************************
void ESI_startInternalOscCal(void)
{
    assert(ESIOSC | ESIHFSEL);
    ESIOSC |= ESICLKGON;
}

//*****************************************************************************
//
//! Adjusts frequency ESI internal Oscillator
//!
//! This function adjusts frequency ESI internal Oscillator. It increases or
//! decrease the freq by 3% based on incOrDec value.
//!
//! \return None
//
//*****************************************************************************
void ESI_adjustInternalOscFreq(uint16_t incOrDec)
{
    uint16_t adjustValue;

    assert(ESIOSC | ESIHFSEL);

    adjustValue = ESIOSC >> 8;

    if(incOrDec == ESI_INTERNAL_OSC_FREQ_INCREASE)
    {
        adjustValue = adjustValue + 1;
        adjustValue = adjustValue << 8;
    }
    else
    {
        adjustValue = adjustValue - 1;
        adjustValue = adjustValue << 8;
    }

    ESIOSC |= adjustValue;
}

//*****************************************************************************
//
//! Sets frequency of ESI internal Oscillator
//!
//!
//! \return None
//
//*****************************************************************************
void ESI_setNominalInternalOscFreq(void)
{
    ESIOSC = ESICLKFQ5 + ESICLKGON + ESIHFSEL;
}

//*****************************************************************************
//
//! The following function return the number of ESIOSC cycle during an ACLK
//! cycle.
//!
//!
//! \return None
//
//*****************************************************************************
static uint16_t measureESIOSC(void){
    // This and next instruction realizes a clear->set ESICLKGON bit.
    ESIOSC &= ~(ESICLKGON);

    // This starts measurement.
    ESIOSC |= ESICLKGON + ESIHFSEL;

    // Reading ESICNT3 while counting always result in reading a 0x01.
    while(ESICNT3 == 1)
    {
        ;
    }

    // Stop ESIOSC oscillator
    ESIOSC &= ~(ESICLKGON);

    return (ESICNT3);
}

//******************************************************************************
//! The following function returns the ESICLKFQx bits on ESIOSC register
//
//! \param none
//
//! \return ESICLKFQ bits only
//******************************************************************************

uint8_t ESI_getESICLKFQ(void){
    uint16_t temp;

    // Store ESIOSC content
    temp = ESIOSC;
    // Get ESICLKFQx bits
    temp = (temp >> 8) & 0x3F;

    return(temp);
}

//******************************************************************************
//! The following function sets ESICLKFQx bits on ESIOSC register
//
//! \param setting is to the loaded to ESIOSC. Valid parameters a value between
//!		   0x00 and 0x3F. 0x00 corresponds to minimum frequency, 0x20
//!		   corresponds to nominal frequency and 0x3F corresponds to maximum
//!		   frequency.
//
//! \return none
//******************************************************************************
void ESI_setESICLKFQ(uint8_t setting)
{
    uint16_t temp;

    assert(setting < 0x40);

    temp = ESIOSC;                         // get actual ESIOSC register content
    temp &= ~(0x3F00);
    temp = ((uint16_t) setting << 8) + temp;     // and update ESICLKFQ bits
    ESIOSC = temp;
}

//*****************************************************************************
//
//! Calibrate ESI internal Oscillator
//!
//!
//! \return None
//
//*****************************************************************************
void ESI_calibrateInternalOscFreq(uint16_t targetAclkCounts)
{
    ESI_setNominalInternalOscFreq();

    ESI_measureESIOSC(ESI_ESIOSC_OVERSAMPLE_4);

    if(ESICNT3 > targetAclkCounts)
    {
        //freq is too high
        do
        {
            ESI_adjustInternalOscFreq(ESI_INTERNAL_OSC_FREQ_DECREASE);
        }
        while(ESI_measureESIOSC(ESI_ESIOSC_OVERSAMPLE_4) > targetAclkCounts);
    }
    else
    {
        //freq is too low
        do
        {
            ESI_adjustInternalOscFreq(ESI_INTERNAL_OSC_FREQ_INCREASE);
        }
        while(ESI_measureESIOSC(ESI_ESIOSC_OVERSAMPLE_4) > targetAclkCounts);
        ESI_adjustInternalOscFreq(ESI_INTERNAL_OSC_FREQ_DECREASE);
    }
}

//*****************************************************************************
//
//! The following function returns an average of ESIOSC measurement.
//!
//! \param
//!
//! \return averaged ESIOSC measurement.
//
//*****************************************************************************
uint16_t ESI_measureESIOSC(uint8_t oversample){
    uint8_t i;
    uint16_t temp = 0;

    assert(oversample < 9);

    for(i = oversample; i > 0; i--)
    {
        temp += measureESIOSC();
    }

    temp /= oversample;
    return(temp);
}

//*****************************************************************************
//
//! Set upper threshold for PSM counter 1
//!
//! \param threshold is the upper threashold that causes ESIIFG3 to get set.
//!
//! This function sets the threshold value for PSM counter 1. ESIIFG3 gets set
//! when counter value and this threahold are equal.
//!
//! \return None
//
//*****************************************************************************
void ESI_setPSMCounter1UpperThreshold(uint16_t threshold)
{
    ESITHR1 = threshold;
}

//*****************************************************************************
//
//! Set lower threshold for PSM counter 1
//!
//! \param threshold is the lower threashold that causes ESIIFG3 to get set.
//!
//! This function set the threshold value for PSM counter 1. ESIIFG3 gets set
//! when counter value and this threahold are equal.
//!
//! \return None
//
//*****************************************************************************
void ESI_setPSMCounter1LowerThreshold(uint16_t threshold)
{
    ESITHR2 = threshold;
}

//*****************************************************************************
//
//! sets AFE1 DAC threshold Value
//!
//! \param dacValue is value to be written to DAC register.
//! \param dacRegNum is DAC register number
//!
//! Write DAC threshold value into selected DAC register
//!
//! \return None
//
//*****************************************************************************
void ESI_setAFE1DACValue(uint16_t dacValue,
                         uint8_t dacRegNum)
{
    volatile uint16_t* dacRegBase = (volatile uint16_t*) &ESIDAC1R0;
    *(dacRegBase + dacRegNum) = dacValue;
}

//*****************************************************************************
//
//! gets AFE1 DAC threshold Value
//!
//! \param dacValue is value to be written to DAC register.
//! \param dacRegNum is DAC register number
//!
//! Read DAC threshold value into selected DAC register
//!
//! \return DAC value from selected DAC register.
//
//*****************************************************************************
uint16_t ESI_getAFE1DACValue(uint8_t dacRegNum)
{
    volatile uint16_t* dacRegBase = (volatile uint16_t*) &ESIDAC1R0;
    return(*(dacRegBase + dacRegNum));
}

//*****************************************************************************
//
//! sets AFE2 DAC threshold Value
//!
//! \param dacValue is value to be written to DAC register.
//! \param dacRegNum is DAC register number
//!
//! Write DAC threshold value into selected DAC register
//!
//! \return None
//
//*****************************************************************************
void ESI_setAFE2DACValue(uint16_t dacValue,
                         uint8_t dacRegNum)
{
    volatile uint16_t* dacRegBase = (volatile uint16_t*) &ESIDAC2R0;
    *(dacRegBase + dacRegNum) = dacValue;
}

//*****************************************************************************
//
//! gets AFE2 DAC threshold Value
//!
//! \param dacValue is value to be written to DAC register.
//! \param dacRegNum is DAC register number
//!
//! Read DAC threshold value into selected DAC register
//!
//! \return DAC value from selected DAC register.
//
//*****************************************************************************
uint16_t ESI_getAFE2DACValue(uint8_t dacRegNum)
{
    volatile uint16_t* dacRegBase = (volatile uint16_t*) &ESIDAC2R0;
    return(*(dacRegBase + dacRegNum));
}

//*****************************************************************************
//
//! sets TSM state register
//!
//! \param params constructs the state value
//! \param stateRegNum is state register offset
//!
//! Sets selected TSM state register.
//!
//! \return None
//
//*****************************************************************************
void ESI_setTSMstateReg(ESI_TSM_StateParams *params,
                        uint8_t stateRegNum)
{
    volatile uint16_t* stateRegBase = (volatile uint16_t*) &ESITSM0;
    *(stateRegBase + stateRegNum) =
        (params->inputChannelSelect +
         params->LCDampingSelect +
         params->excitationSelect +
         params->comparatorSelect +
         params->highFreqClkOn_or_compAutoZeroCycle +
         params->outputLatchSelect +
         params->testCycleSelect +
         params->dacSelect +
         params->tsmStop +
         params->tsmClkSrc) |
        (params->duration << 11);
}

//*****************************************************************************
//
//! Get ESI interrupt Vector Register
//!
//! \return None
//
//*****************************************************************************
uint16_t ESI_getInterruptVectorRegister(void)
{
    return (ESIIV);
}

//*****************************************************************************
//
//! Enables ESI interrupts
//!
//! \param interruptMask is the bit mask of the interrupt sources to
//!        be enabled. Mask value is the logical OR of any of the following:
//!        \b ESI_INTERRUPT_AFE1_ESIOUTX
//!		   \b ESI_INTERRUPT_ESISTOP
//!		   \b ESI_INTERRUPT_ESISTART
//!		   \b ESI_INTERRUPT_ESICNT1
//!		   \b ESI_INTERRUPT_ESICNT2
//!		   \b ESI_INTERRUPT_Q6_BIT_SET
//!		   \b ESI_INTERRUPT_Q7_BIT_SET
//!		   \b ESI_INTERRUPT_ESICNT0_COUNT_INTERVAL
//!		   \b ESI_INTERRUPT_AFE2_ESIOUTX
//!
//! Modified bits of \b ESIINT1 register.
//!
//! \return None
//
//*****************************************************************************
void ESI_enableInterrupt(uint16_t interruptMask)
{
    ESIINT1 |= (interruptMask);
}

//*****************************************************************************
//
//! Disables ESI interrupts
//!
//! \param interruptMask is the bit mask of the interrupt sources to
//!        be disabled. Mask value is the logical OR of any of the following:
//!        \b ESI_INTERRUPT_AFE1_ESIOUTX
//!		   \b ESI_INTERRUPT_ESISTOP
//!		   \b ESI_INTERRUPT_ESISTART
//!		   \b ESI_INTERRUPT_ESICNT1
//!		   \b ESI_INTERRUPT_ESICNT2
//!		   \b ESI_INTERRUPT_Q6_BIT_SET
//!		   \b ESI_INTERRUPT_Q7_BIT_SET
//!		   \b ESI_INTERRUPT_ESICNT0_COUNT_INTERVAL
//!		   \b ESI_INTERRUPT_AFE2_ESIOUTX
//!
//! Modified bits of \b ESIINT1 register.
//!
//! \return None
//
//*****************************************************************************
void ESI_disableInterrupt(uint16_t interruptMask)
{
    ESIINT1 &= ~(interruptMask);
}

//*****************************************************************************
//
//! Get ESI interrupt status
//!
//! \param interruptMask is the masked interrupt flag status to be returned.
//!        Mask value is the logical OR of any of the following:
//!        - \b ESI_INTERRUPT_FLAG_AFE1_ESIOUTX
//!        - \b ESI_INTERRUPT_FLAG_ESISTOP
//!        - \b ESI_INTERRUPT_FLAG_ESISTART
//!        - \b ESI_INTERRUPT_FLAG_ESICNT1
//!        - \b ESI_INTERRUPT_FLAG_ESICNT2
//!		   - \b ESI_INTERRUPT_FLAG_Q6_BIT_SET
//!        - \b ESI_INTERRUPT_FLAG_Q7_BIT_SET
//!        - \b ESI_INTERRUPT_FLAG_ESICNT0_COUNT_INTERVAL
//!        - \b ESI_INTERRUPT_FLAG_AFE2_ESIOUTX
//!
//! \return Logical OR of any of the following:
//!        - \b ESI_INTERRUPT_FLAG_AFE1_ESIOUTX
//!        - \b ESI_INTERRUPT_FLAG_ESISTOP
//!        - \b ESI_INTERRUPT_FLAG_ESISTART
//!        - \b ESI_INTERRUPT_FLAG_ESICNT1
//!        - \b ESI_INTERRUPT_FLAG_ESICNT2
//!        - \b ESI_INTERRUPT_FLAG_Q6_BIT_SET
//!        - \b ESI_INTERRUPT_FLAG_Q7_BIT_SET
//!        - \b ESI_INTERRUPT_FLAG_ESICNT0_COUNT_INTERVAL
//!        - \b ESI_INTERRUPT_FLAG_AFE2_ESIOUTX
//!         \n indicating the status of the masked flags
//
//*****************************************************************************
uint16_t ESI_getInterruptStatus(uint16_t interruptMask)
{
    return (ESIINT2 & interruptMask);
}

//*****************************************************************************
//
//! Clear ESI interrupt flag
//!
//! \param interruptMask is the masked interrupt flag status to be returned.
//!        Mask value is the logical OR of any of the following:
//!        - \b ESI_INTERRUPT_FLAG_AFE1_ESIOUTX
//!        - \b ESI_INTERRUPT_FLAG_ESISTOP
//!        - \b ESI_INTERRUPT_FLAG_ESISTART
//!        - \b ESI_INTERRUPT_FLAG_ESICNT1
//!        - \b ESI_INTERRUPT_FLAG_ESICNT2
//!		   - \b ESI_INTERRUPT_FLAG_Q6_BIT_SET
//!        - \b ESI_INTERRUPT_FLAG_Q7_BIT_SET
//!        - \b ESI_INTERRUPT_FLAG_ESICNT0_COUNT_INTERVAL
//!        - \b ESI_INTERRUPT_FLAG_AFE2_ESIOUTX
//!
//! \return None
//
//*****************************************************************************
void ESI_clearInterrupt(uint16_t interruptMask)
{
    ESIINT2 &= ~(interruptMask);
}

//*****************************************************************************
//
//! Set source of IFG0 interrupt flag
//!
//! \param ifg0Src values are as follows
//!         ESI_IFG0_SET_WHEN_ESIOUT0_SET
//!         ESI_IFG0_SET_WHEN_ESIOUT0_RESET
//!         ESI_IFG0_SET_WHEN_ESIOUT1_SET
//!         ESI_IFG0_SET_WHEN_ESIOUT1_RESET
//!         ESI_IFG0_SET_WHEN_ESIOUT2_SET
//!         ESI_IFG0_SET_WHEN_ESIOUT2_RESET
//!         ESI_IFG0_SET_WHEN_ESIOUT3_SET
//!         ESI_IFG0_SET_WHEN_ESIOUT3_RESET
//!
//! \return None
//
//*****************************************************************************
void ESI_setIFG0Source(uint16_t ifg0Src)
{
    ESIINT1 &= ~ESI_IFG0_SET_WHEN_ESIOUT3_RESET;
    ESIINT1 |= ifg0Src;
}

//*****************************************************************************
//
//! Set source of IFG8 interrupt flag
//!
//! \param ifg8Src values are as follows
//!         ESI_IFG8_SET_WHEN_ESIOUT4_SET
//!         ESI_IFG8_SET_WHEN_ESIOUT4_RESET
//!         ESI_IFG8_SET_WHEN_ESIOUT5_SET
//!         ESI_IFG8_SET_WHEN_ESIOUT5_RESET
//!         ESI_IFG8_SET_WHEN_ESIOUT6_SET
//!         ESI_IFG8_SET_WHEN_ESIOUT6_RESET
//!         ESI_IFG8_SET_WHEN_ESIOUT7_SET
//!         ESI_IFG8_SET_WHEN_ESIOUT7_RESET
//!
//! \return None
//
//*****************************************************************************
void ESI_setIFG8Source(uint16_t ifg8Src)
{
    ESIINT1 &= ~ESI_IFG8_SET_WHEN_ESIOUT7_RESET;
    ESIINT1 |= ifg8Src;
}

//*****************************************************************************
//
//! Set source of IFG7 interrupt flag
//!
//! \param ifg7Src values are as follows
//!         ESI_IFG7_SOURCE_EVERY_COUNT_OF_CNT0
//!         ESI_IFG7_SOURCE_CNT0_MOD4
//!         ESI_IFG7_SOURCE_CNT0_MOD256
//!         ESI_IFG7_SOURCE_CNT0_ROLLOVER
//!
//! \return None
//
//*****************************************************************************
void ESI_setIFG7Source(uint16_t ifg7Src)
{
    ESIINT2 &= ~ESI_IFG7_SOURCE_CNT0_ROLLOVER;
    ESIINT2 |= ifg7Src;
}

//*****************************************************************************
//
//! Set source of IFG4 interrupt flag
//!
//! \param ifg4Src values are as follows
//!         ESI_IFG4_SOURCE_EVERY_COUNT_OF_CNT2
//!         ESI_IFG4_SOURCE_CNT2_MOD4
//!         ESI_IFG4_SOURCE_CNT2_MOD256
//!         ESI_IFG4_SOURCE_CNT2_ROLLOVER
//!
//! \return None
//
//*****************************************************************************
void ESI_setIFG4Source(uint16_t ifg4Src)
{
    ESIINT2 &= ~ESI_IFG4_SOURCE_CNT2_ROLLOVER;
    ESIINT2 |= ifg4Src;
}

//*****************************************************************************
//
//! Simple DAC calibration code using pre-defined TSM
//! Supports AFE1 only.
//! \param selected_channel acceptable values
//!         ESI_AFE1_CHANNEL0_SELECT
//!         ESI_AFE1_CHANNEL1_SELECT
//!         ESI_AFE1_CHANNEL2_SELECT
//!         ESI_AFE1_CHANNEL3_SELECT
//!
//!
//! \return None
//
//*****************************************************************************
void ESI_LC_DAC_calibration(uint8_t selected_channel)
{
#define NUM_SENSOR_CAL  4
#define MIN_HYSTERESIS  30
#define STEP_TO_FINISH  4

    unsigned int i;
    unsigned char test_bit, done;
    unsigned int hysteresis[NUM_SENSOR_CAL],
                 hysteresis_hi[NUM_SENSOR_CAL],
                 hysteresis_lo[NUM_SENSOR_CAL],
                 current[NUM_SENSOR_CAL],
                 average[NUM_SENSOR_CAL],
                 max[NUM_SENSOR_CAL],
                 min[NUM_SENSOR_CAL];

    // State:	0 = output low
    //			1 = output high
    //			2 = undetermined (between 2 hysteresis level)
    unsigned char previous_state[NUM_SENSOR_CAL],
                  current_state[NUM_SENSOR_CAL],
                  step[NUM_SENSOR_CAL];

    // Reset values
    for(i = 0; i < NUM_SENSOR_CAL; i++)
    {
        max[i] = 0;
        min[i] = 0xffff;
        previous_state[i] = 2;
        step[i] = 0;
    }

    do
    {
        // Find the current oscillating level, using software mode
        FindDAC(selected_channel, 1);

        test_bit = 1;
        done = 1;

        for(i = 0; i < NUM_SENSOR_CAL; i++)
        {
            // skip if the channel is not selected
            if(test_bit & selected_channel)
            {
                current[i] = ESI_getAFE1DACValue(i * 2);

                // Record max and min value
                if(current[i] > max[i])
                {
                    max[i] = current[i];
                }
                if(current[i] < min[i])
                {
                    min[i] = current[i];
                }

                // Update average and hysteresis level
                average[i] = (max[i] + min[i]) >> 1;
                hysteresis[i] = (max[i] - min[i]) >> 3;

                if(hysteresis[i] < MIN_HYSTERESIS)
                {
                    hysteresis[i] = MIN_HYSTERESIS;
                }

                hysteresis[i] >>= 1;
                hysteresis_hi[i] = average[i] + hysteresis[i];
                hysteresis_lo[i] = average[i] - hysteresis[i];

                // Determine output state based on hysteresis_hi and hysteresis_lo
                if(current[i] < hysteresis_lo[i])
                {
                    current_state[i] = 0;
                }
                else if(current[i] > hysteresis_hi[i])
                {
                    current_state[i] = 1;
                }
                else
                {
                    current_state[i] = 2;
                }

                // If there is state change, proceed to next step
                switch(current_state[i])
                {
                case 0:
                case 1:
                    if(previous_state[i] != current_state[i])
                    {
                        step[i]++;
                        previous_state[i] = current_state[i];
                    }
                    break;

                default:
                    break;
                }

                // Any selected sensor which has not finished calibration will set done to zero
                if(step[i] < STEP_TO_FINISH)
                {
                    done = 0;
                }
            }
            test_bit <<= 1;
        }
    }
    while(!done);

    // Record DAC Values
    test_bit = 1;
    done = ESI_DAC1_REG0;               // Temp value for recording DAC
    for(i = 0; i < NUM_SENSOR_CAL; i++)
    {
        if(test_bit & selected_channel)
        {
            ESI_setAFE1DACValue(hysteresis_hi[i], done++);
            ESI_setAFE1DACValue(hysteresis_lo[i], done++);
        }
        test_bit <<= 1;
    }
}

//*****************************************************************************
//
//! Find the current oscillating level, using software mode
//!
//!
//! \return None
//
//*****************************************************************************

static void FindDAC(unsigned char selected_channel,
                    unsigned char software_trigger)
{
    // DAC Level tester, using successive approximation approach
    unsigned int DAC_BIT = 0x0800, Prev_DAC_BIT = 0x0C00;

    unsigned int i;
    unsigned int test_bit, DAC_index;

    // Set initial DAC value for each selected channel

    // AFE 1
    if(selected_channel & 0x0f)
    {
        test_bit = 0x01;
        DAC_index = ESI_DAC1_REG0;
        for(i = 0; i < 4; i++)
        {
            if(selected_channel & test_bit)
            {
                ESI_setAFE1DACValue(DAC_BIT, DAC_index++);
                ESI_setAFE1DACValue(DAC_BIT, DAC_index++);
            }
            else
            {
                DAC_index += 2;
            }
            test_bit <<= 1;
        }
    }

    // AFE 2
    if(selected_channel & 0xf0)
    {
        test_bit = 0x10;
        DAC_index = ESI_DAC2_REG0;
        for(i = 0; i < 4; i++)
        {
            if(selected_channel & test_bit)
            {
                ESI_setAFE2DACValue(DAC_BIT, DAC_index++);
                ESI_setAFE2DACValue(DAC_BIT, DAC_index++);
            }
            else
            {
                DAC_index += 2;
            }
            test_bit <<= 1;
        }
    }

    ESI_enableInterrupt(ESI_INTERRUPT_ESISTOP);                 // enable ESISTOP INT

    // Find the DAC value for each selected channel
    do
    {
        ESI_clearInterrupt (ESI_INTERRUPT_FLAG_ESISTOP);

        if(software_trigger)
        {
            ESI_TSM_softwareTrigger();
        }

        __bis_SR_register(LPM3_bits + GIE);                     // wait for the ESISTOP flag
        DAC_BIT >>= 1;                                                          // right shift one bit

        // AFE 1
        if(selected_channel & 0x0f)
        {
            test_bit = 0x01;
            DAC_index = ESI_DAC1_REG0;
            for(i = 0; i < 4; i++)
            {
                if(selected_channel & test_bit)
                {
#ifndef INVERTED
                    if(ESI_getLatchedComparatorOutput(test_bit) ==
                       ESI_AFE_OUTPUT_HIGH)
#else
                    if(ESI_getLatchedComparatorOutput(test_bit) ==
                       ESI_AFE_OUTPUT_LOW)
#endif
                    {
                        ESI_setAFE1DACValue(ESI_getAFE1DACValue(
                                                DAC_index) | DAC_BIT,
                                            DAC_index);
                        DAC_index++;
                        ESI_setAFE1DACValue(ESI_getAFE1DACValue(
                                                DAC_index) | DAC_BIT,
                                            DAC_index);
                        DAC_index++;
                    }
                    else
                    {
                        ESI_setAFE1DACValue(ESI_getAFE1DACValue(
                                                DAC_index) ^ Prev_DAC_BIT,
                                            DAC_index);
                        DAC_index++;
                        ESI_setAFE1DACValue(ESI_getAFE1DACValue(
                                                DAC_index) ^ Prev_DAC_BIT,
                                            DAC_index);
                        DAC_index++;
                    }
                }
                else
                {
                    DAC_index += 2;
                }
                test_bit <<= 1;
            }
        }

        // AFE 2
        if(selected_channel & 0xf0)
        {
            test_bit = 0x10;
            DAC_index = ESI_DAC2_REG0;
            for(i = 0; i < 4; i++)
            {
                if(selected_channel & test_bit)
                {
#ifndef INVERTED
                    if(ESI_getLatchedComparatorOutput(test_bit) ==
                       ESI_AFE_OUTPUT_HIGH)
#else
                    if(ESI_getLatchedComparatorOutput(test_bit) ==
                       ESI_AFE_OUTPUT_LOW)
#endif
                    {
                        ESI_setAFE1DACValue(ESI_getAFE2DACValue(
                                                DAC_index) | DAC_BIT,
                                            DAC_index);
                        DAC_index++;
                        ESI_setAFE1DACValue(ESI_getAFE2DACValue(
                                                DAC_index) | DAC_BIT,
                                            DAC_index);
                        DAC_index++;
                    }
                    else
                    {
                        ESI_setAFE1DACValue(ESI_getAFE2DACValue(
                                                DAC_index) ^ Prev_DAC_BIT,
                                            DAC_index);
                        DAC_index++;
                        ESI_setAFE1DACValue(ESI_getAFE2DACValue(
                                                DAC_index) ^ Prev_DAC_BIT,
                                            DAC_index);
                        DAC_index++;
                    }
                }
                else
                {
                    DAC_index += 2;
                }
                test_bit <<= 1;
            }
        }
        Prev_DAC_BIT >>= 1;                                             // right shift one bit
    }
    while(DAC_BIT);

    ESI_disableInterrupt(ESI_INTERRUPT_ESISTOP);
    __no_operation();
}

//*****************************************************************************
//
//! Close the doxygen group for esi_api
//! @}
//
//*****************************************************************************
#endif