void ADC_Init() {
uint8_t i;
IRQn_Type irqNum[4] = {ADC00_IRQn, ADC01_IRQn, ADC02_IRQn, ADC03_IRQn};
// Enable VBAT unity gain buffer
SYS->IVSCTL |= SYS_IVSCTL_VBATUGEN_Msk;
// Set internal 2.56V voltage reference
SYS->VREFCTL = SYS_VREFCTL_VREF_2_56V;
// Configure PB.0 - PB.6 analog input pins
SYS->GPB_MFPL &= ~(SYS_GPB_MFPL_PB0MFP_Msk | SYS_GPB_MFPL_PB1MFP_Msk |
SYS_GPB_MFPL_PB2MFP_Msk | SYS_GPB_MFPL_PB3MFP_Msk |
SYS_GPB_MFPL_PB4MFP_Msk | SYS_GPB_MFPL_PB5MFP_Msk |
SYS_GPB_MFPL_PB6MFP_Msk);
SYS->GPB_MFPL |= (SYS_GPB_MFPL_PB0MFP_EADC_CH0 | SYS_GPB_MFPL_PB1MFP_EADC_CH1 |
SYS_GPB_MFPL_PB2MFP_EADC_CH2 | SYS_GPB_MFPL_PB3MFP_EADC_CH3 |
SYS_GPB_MFPL_PB4MFP_EADC_CH4 | SYS_GPB_MFPL_PB5MFP_EADC_CH13 |
SYS_GPB_MFPL_PB6MFP_EADC_CH14);
// Disable PB.0 - PB.6 digital input paths to avoid leakage currents
GPIO_DISABLE_DIGITAL_PATH(PB, 0x7F);
// Configure ADC (single-ended)
EADC_Open(EADC, EADC_CTL_DIFFEN_SINGLE_END);
EADC_SetInternalSampleTime(EADC, 6);
// Enable interrupts
for(i = 0; i < 4; i++) {
EADC_ENABLE_INT(EADC, 1 << i);
NVIC_EnableIRQ(irqNum[i]);
}
}
// ---------------------------------------------------------------------------------------
// Gas ADC initialize setting
// Set PB2 as ADC converter
// Select APB0/8 as ADC module clock source
// ---------------------------------------------------------------------------------------
void ID_Init()
{
SYS_UnlockReg();
/* Enable EADC module clock */
CLK_EnableModuleClock(EADC_MODULE);
/* EADC clock source is 72MHz, set divider to 8, ADC clock is 72/8 MHz */
CLK_SetModuleClock(EADC_MODULE, 0, CLK_CLKDIV0_EADC(8));
SYS_LockReg();
/* Configure the GPB0 - GPB3 ADC analog input pins. */
SYS->GPB_MFPL &= ~SYS_GPB_MFPL_PB0MFP_Msk;
SYS->GPB_MFPL |= SYS_GPB_MFPL_PB0MFP_EADC_CH0;
GPIO_DISABLE_DIGITAL_PATH(PB, BIT0);
/* Set the ADC internal sampling time, input mode as single-end and enable the A/D converter */
EADC_Open(EADC, EADC_CTL_DIFFEN_SINGLE_END);
EADC_SetInternalSampleTime(EADC, 6);
/* Configure the sample module 0 for analog input channel 1 and software trigger source.*/
EADC_ConfigSampleModule(EADC, 0, EADC_SOFTWARE_TRIGGER, 0);
/* Clear the A/D ADINT0 interrupt flag for safe */
EADC_CLR_INT_FLAG(EADC, 0x1);
/* Enable the sample module 0 interrupt. */
EADC_ENABLE_INT(EADC, 0x1);//Enable sample module A/D ADINT0 interrupt.
EADC_ENABLE_SAMPLE_MODULE_INT(EADC, 0, 0x1);//Enable sample module 0 interrupt.
}
//=============================================================================
//----- (0000184C) --------------------------------------------------------
__myevic__ uint32_t ADC_Read( uint32_t module )
{
EADC_Open( EADC, EADC_CTL_DIFFEN_SINGLE_END );
EADC_SetInternalSampleTime( EADC, 6 ); // 0.67 us
EADC_ConfigSampleModule( EADC, module, EADC_SOFTWARE_TRIGGER, module );
EADC_CLR_INT_FLAG( EADC, 1 << 0 );
EADC_ENABLE_INT( EADC, 1 << 0 );
EADC_ENABLE_SAMPLE_MODULE_INT( EADC, 0, 1 << module );
NVIC_EnableIRQ( ADC00_IRQn );
ADC00_IRQ_Flag = 0;
EADC_START_CONV( EADC, 1 << module );
while ( !ADC00_IRQ_Flag )
;
EADC_DISABLE_INT( EADC, 1 << 0 );
return EADC_GET_CONV_DATA( EADC, module );
}
void Battery_Init(void)
{
#ifdef M451
SYS_UnlockReg();
/* Enable EADC module clock */
CLK_EnableModuleClock(EADC_MODULE);
/* EADC clock source is 72MHz, set divider to 8, ADC clock is 72/8 MHz */
CLK_SetModuleClock(EADC_MODULE, 0, CLK_CLKDIV0_EADC(8));
SYS_LockReg();
/* Configure the GPB0 - GPB3 ADC analog input pins. */
SYS->GPB_MFPL &= ~SYS_GPB_MFPL_PB2MFP_Msk;
SYS->GPB_MFPL |= SYS_GPB_MFPL_PB2MFP_EADC_CH2;
GPIO_DISABLE_DIGITAL_PATH(PB, 0x4);
/* Set the ADC internal sampling time, input mode as single-end and enable the A/D converter */
EADC_Open(EADC, EADC_CTL_DIFFEN_SINGLE_END);
EADC_SetInternalSampleTime(EADC, 6);
/* Configure the sample module 0 for analog input channel 2 and software trigger source.*/
EADC_ConfigSampleModule(EADC, 0, EADC_SOFTWARE_TRIGGER, 2);
/* Clear the A/D ADINT0 interrupt flag for safe */
EADC_CLR_INT_FLAG(EADC, 0x1);
/* Enable the sample module 0 interrupt. */
EADC_ENABLE_INT(EADC, 0x1);//Enable sample module A/D ADINT0 interrupt.
EADC_ENABLE_SAMPLE_MODULE_INT(EADC, 0, 0x1);//Enable sample module 0 interrupt.
/* Reset the ADC interrupt indicator and trigger sample module 0 to start A/D conversion */
g_u32AdcIntFlag = 0;
/* Enable battery detect circuit (PA3=1)*/
GPIO_SetMode(PA, BIT3, GPIO_MODE_OUTPUT);
PA3=1;
#else
/* TBD.. */
#endif
}
/*---------------------------------------------------------------------------------------------------------*/
void EADC_FunctionTest()
{
printf("\n");
printf("+----------------------------------------------------------------------+\n");
printf("| EADC compare function (result monitor) sample code |\n");
printf("+----------------------------------------------------------------------+\n");
printf("\nIn this test, software will compare the conversion result of channel 2.\n");
/* Set the ADC internal sampling time, input mode as single-end and enable the A/D converter */
EADC_Open(EADC, EADC_CTL_DIFFEN_SINGLE_END);
EADC_SetInternalSampleTime(EADC, 6);
/* Configure the sample module 0 for analog input channel 2 and ADINT0 trigger source */
EADC_ConfigSampleModule(EADC, 0, EADC_ADINT0_TRIGGER, 2);
/* Enable EADC comparator 0. Compare condition: conversion result < 0x800; match Count=5 */
printf(" Set the compare condition of comparator 0: channel 2 is less than 0x800; match count is 5.\n");
EADC_ENABLE_CMP0(EADC, 0, EADC_CMP_CMPCOND_LESS_THAN, 0x800, 0x5);
/* Enable EADC comparator 1. Compare condition: conversion result >= 0x800; match Count=5 */
printf(" Set the compare condition of comparator 1 : channel 2 is greater than or equal to 0x800; match count is 5.\n");
EADC_ENABLE_CMP1(EADC, 0, EADC_CMP_CMPCOND_GREATER_OR_EQUAL, 0x800, 0x5);
/* Enable sample module 0 interrupt */
EADC_ENABLE_SAMPLE_MODULE_INT(EADC, 0, 0x1);
/* Clear the A/D ADINT3 interrupt flag for safe */
EADC_CLR_INT_FLAG(EADC, (0x1 << 3));
/* Enable ADINT3 interrupt */
EADC_ENABLE_INT(EADC, (0x1 << 3));
NVIC_EnableIRQ(ADC03_IRQn);
/* Clear the EADC comparator 0 interrupt flag for safe */
EADC_CLR_INT_FLAG(EADC, (0x1 << 4));
/* Enable ADC comparator 0 interrupt */
EADC_ENABLE_CMP_INT(EADC, 0);
/* Clear the EADC comparator 1 interrupt flag for safe */
EADC_CLR_INT_FLAG(EADC, (0x1 << 5));
/* Enable ADC comparator 1 interrupt */
EADC_ENABLE_CMP_INT(EADC, 1);
/* Reset the EADC interrupt indicator and trigger sample module 0 to start A/D conversion */
g_u32AdcCmp0IntFlag = 0;
g_u32AdcCmp1IntFlag = 0;
EADC_START_CONV(EADC, 0x1);
/* Wait EADC compare interrupt */
while((g_u32AdcCmp0IntFlag == 0) && (g_u32AdcCmp1IntFlag == 0));
/* Disable the sample module 0 interrupt */
EADC_DISABLE_SAMPLE_MODULE_INT(EADC, 0, 0x1);
/* Disable ADC comparator interrupt */
EADC_DISABLE_CMP_INT(EADC, 0);
EADC_DISABLE_CMP_INT(EADC, 1);
/* Disable compare function */
EADC_DISABLE_CMP0(EADC);
EADC_DISABLE_CMP1(EADC);
if(g_u32AdcCmp0IntFlag == 1)
{
printf("Comparator 0 interrupt occurs.\nThe conversion result of channel 2 is less than 0x800\n");
}
else
{
printf("Comparator 1 interrupt occurs.\nThe conversion result of channel 2 is greater than or equal to 0x800\n");
}
}
/* ---------------------------------------------------------------------------------------*/
void Battery_Init()
{
SYS_UnlockReg();
/* Enable EADC module clock */
CLK_EnableModuleClock(EADC_MODULE);
/* EADC clock source is 72MHz, set divider to 8, ADC clock is 72/8 MHz */
CLK_SetModuleClock(EADC_MODULE, 0, CLK_CLKDIV0_EADC(8));
SYS_LockReg();
/* Configure the GPB0 - GPB3 ADC analog input pins. */
SYS->GPB_MFPL &= ~SYS_GPB_MFPL_PB1MFP_Msk;
SYS->GPB_MFPL |= SYS_GPB_MFPL_PB1MFP_EADC_CH1;
GPIO_DISABLE_DIGITAL_PATH(PB, BIT1);
//LED
SYS->GPA_MFPL &= ~(SYS_GPA_MFPL_PA2MFP_Msk);
SYS->GPA_MFPL |= SYS_GPA_MFPL_PA2MFP_GPIO;
GPIO_SetMode(PA,BIT2,GPIO_MODE_OUTPUT);
PA2 = 1;
/* Set the ADC internal sampling time, input mode as single-end and enable the A/D converter */
EADC_Open(EADC, EADC_CTL_DIFFEN_SINGLE_END);
EADC_SetInternalSampleTime(EADC, 6);
/* Configure the sample module 0 for analog input channel 1 and software trigger source.*/
EADC_ConfigSampleModule(EADC, 1, EADC_SOFTWARE_TRIGGER, 1);
/* Clear the A/D ADINT0 interrupt flag for safe */
EADC_CLR_INT_FLAG(EADC, 0x2);
/* Enable the sample module 0 interrupt. */
EADC_ENABLE_INT(EADC, 0x2);//Enable sample module A/D ADINT0 interrupt.
EADC_ENABLE_SAMPLE_MODULE_INT(EADC, 1, 0x2);//Enable sample module 0 interrupt.
BatDev.DevDesc.DevDesc_leng = 26; //Report descriptor
BatDev.DevDesc.RptDesc_leng = 36; //Report descriptor
BatDev.DevDesc.InRptLeng = 5; //Input report
BatDev.DevDesc.OutRptLeng = 0; //Output report
BatDev.DevDesc.GetFeatLeng = 6; //Get feature
BatDev.DevDesc.SetFeatLeng = 6; //Set feature
BatDev.DevDesc.CID = 0; //manufacturers ID
BatDev.DevDesc.DID = 0; //Product ID
BatDev.DevDesc.PID = 0; //Device firmware revision
BatDev.DevDesc.UID = 0; //Device Class type
BatDev.DevDesc.UCID = 0; //reserve
/* Feature */
BatDev.Feature.data1.minimum = 0; //Sleep period
BatDev.Feature.data1.maximum = 1024;
BatDev.Feature.data1.value = 100;
BatDev.Feature.data2.minimum = 0; //Battery alerm value
BatDev.Feature.data2.maximum = 100;
BatDev.Feature.data2.value = 50;
BatDev.Feature.arg[0] = 1;
BatDev.Feature.arg[1] = 2;
BatDev.Feature.datalen[0] = 2;
BatDev.Feature.datalen[1] = 2;
BatDev.Feature.dataNum = 2;
/* Input */
BatDev.Input.data1.minimum = 0; //Battery value
BatDev.Input.data1.maximum = 100;
BatDev.Input.data1.value = 100;
BatDev.Input.data2.minimum = 0; //Over flag
BatDev.Input.data2.maximum = 1;
BatDev.Input.data2.value = 0;
BatDev.Input.arg[0] = 1;
BatDev.Input.arg[1] = 2;
BatDev.Input.datalen[0] = 2;
BatDev.Input.datalen[1] = 1;
BatDev.Input.dataNum = 2;
/* Output */
BatDev.Output.dataNum = 0;
}
/*---------------------------------------------------------------------------------------------------------*/
void EADC_FunctionTest()
{
uint8_t u8Option, u32SAMPLECount = 0;
int32_t i32ConversionData[8] = {0};
printf("\n");
printf("+----------------------------------------------------------------------+\n");
printf("| ADINT trigger mode test |\n");
printf("+----------------------------------------------------------------------+\n");
printf("\nIn this test, software will get 2 cycles of conversion result from the specified channels.\n");
while(1)
{
printf("\n\nSelect input mode:\n");
printf(" [1] Single end input (channel 0, 1, 2 and 3)\n");
printf(" [2] Differential input (input channel pair 0 and 1)\n");
printf(" Other keys: exit continuous scan mode test\n");
u8Option = getchar();
if(u8Option == '1')
{
/* Set the ADC internal sampling time, input mode as single-end and enable the A/D converter */
EADC_Open(EADC, EADC_CTL_DIFFEN_SINGLE_END);
EADC_SetInternalSampleTime(EADC, 6);
/* Configure the sample 4 module for analog input channel 0 and enable ADINT0 trigger source */
EADC_ConfigSampleModule(EADC, 4, EADC_ADINT0_TRIGGER, 0);
/* Configure the sample 5 module for analog input channel 1 and enable ADINT0 trigger source */
EADC_ConfigSampleModule(EADC, 5, EADC_ADINT0_TRIGGER, 1);
/* Configure the sample 6 module for analog input channel 2 and enable ADINT0 trigger source */
EADC_ConfigSampleModule(EADC, 6, EADC_ADINT0_TRIGGER, 2);
/* Configure the sample 7 module for analog input channel 3 and enable ADINT0 trigger source */
EADC_ConfigSampleModule(EADC, 7, EADC_ADINT0_TRIGGER, 3);
/* Clear the A/D ADINT0 interrupt flag for safe */
EADC_CLR_INT_FLAG(EADC, 0x1);
/* Enable the sample module 7 interrupt */
EADC_ENABLE_INT(EADC, 0x1);//Enable sample module A/D ADINT0 interrupt.
EADC_ENABLE_SAMPLE_MODULE_INT(EADC, 0, (0x1 << 7));//Enable sample module 7 interrupt.
NVIC_EnableIRQ(ADC00_IRQn);
/* Reset the ADC indicator and trigger sample module 7 to start A/D conversion */
g_u32AdcIntFlag = 0;
g_u32COVNUMFlag = 0;
EADC_START_CONV(EADC, (0x1 << 7));
/* Wait EADC interrupt (g_u32AdcIntFlag will be set at IRQ_Handler function) */
while(g_u32AdcIntFlag == 0);
/* Reset the EADC interrupt indicator */
g_u32AdcIntFlag = 0;
/* Wait EADC interrupt (g_u32AdcIntFlag will be set at IRQ_Handler function) */
while(g_u32AdcIntFlag == 0);
/* Reset the EADC interrupt indicator */
g_u32AdcIntFlag = 0;
/* Disable the sample module 7 interrupt */
EADC_DISABLE_SAMPLE_MODULE_INT(EADC, 0, (0x1 << 7));
/* Get the conversion result of the sample module */
for(u32SAMPLECount = 0; u32SAMPLECount < 4; u32SAMPLECount++)
i32ConversionData[u32SAMPLECount] = EADC_GET_CONV_DATA(EADC, (u32SAMPLECount + 4));
/* Wait conversion done */
while(EADC_GET_DATA_VALID_FLAG(EADC, 0xF0) != 0xF0);
/* Get the conversion result of the sample module */
for(u32SAMPLECount = 4; u32SAMPLECount < 8; u32SAMPLECount++)
i32ConversionData[u32SAMPLECount] = EADC_GET_CONV_DATA(EADC, u32SAMPLECount);
for(g_u32COVNUMFlag = 0; (g_u32COVNUMFlag) < 8; g_u32COVNUMFlag++)
printf("Conversion result of channel %d: 0x%X (%d)\n", (g_u32COVNUMFlag % 4), i32ConversionData[g_u32COVNUMFlag], i32ConversionData[g_u32COVNUMFlag]);
}
else if(u8Option == '2')
{
/* Set the ADC internal sampling time, input mode as differential and enable the A/D converter */
EADC_Open(EADC, EADC_CTL_DIFFEN_DIFFERENTIAL);
EADC_SetInternalSampleTime(EADC, 6);
/* Configure the sample module 4 for analog input channel 0 and enable ADINT0 trigger source */
EADC_ConfigSampleModule(EADC, 4, EADC_ADINT0_TRIGGER, 0);
/* Configure the sample module 5 for analog input channel 1 and enable ADINT0 trigger source */
EADC_ConfigSampleModule(EADC, 5, EADC_ADINT0_TRIGGER, 1);
/* Configure the sample module 6 for analog input channel 2 and enable ADINT0 trigger source */
EADC_ConfigSampleModule(EADC, 6, EADC_ADINT0_TRIGGER, 2);
/* Configure the sample module 7 for analog input channel 3 and enable ADINT0 trigger source */
EADC_ConfigSampleModule(EADC, 7, EADC_ADINT0_TRIGGER, 3);
/* Clear the A/D ADINT0 interrupt flag for safe */
EADC_CLR_INT_FLAG(EADC, 0x1);
/* Enable the sample module 7 interrupt */
EADC_ENABLE_INT(EADC, 0x1);//Enable sample module A/D ADINT0 interrupt.
EADC_ENABLE_SAMPLE_MODULE_INT(EADC, 0, (0x1 << 7));//Enable sample module 7 interrupt.
NVIC_EnableIRQ(ADC00_IRQn);
/* Reset the ADC indicator and trigger sample module 7 to start A/D conversion */
g_u32AdcIntFlag = 0;
g_u32COVNUMFlag = 0;
EADC_START_CONV(EADC, (0x1 << 7));
/* Wait EADC interrupt (g_u32AdcIntFlag will be set at IRQ_Handler function) */
while(g_u32AdcIntFlag == 0);
/* Reset the EADC interrupt indicator */
g_u32AdcIntFlag = 0;
/* Wait EADC interrupt (g_u32AdcIntFlag will be set at IRQ_Handler function) */
while(g_u32AdcIntFlag == 0);
/* Reset the EADC interrupt indicator */
g_u32AdcIntFlag = 0;
/* Disable the sample module 7 interrupt */
EADC_DISABLE_SAMPLE_MODULE_INT(EADC, 0, (0x1 << 7));
/* Get the conversion result of the sample module */
for(u32SAMPLECount = 0; u32SAMPLECount < 4; u32SAMPLECount++)
i32ConversionData[u32SAMPLECount] = EADC_GET_CONV_DATA(EADC, (u32SAMPLECount + 4));
/* Wait conversion done */
while(EADC_GET_DATA_VALID_FLAG(EADC, 0xF0) != 0xF0);
/* Get the conversion result of the sample module */
for(u32SAMPLECount = 4; u32SAMPLECount < 8; u32SAMPLECount++)
i32ConversionData[u32SAMPLECount] = EADC_GET_CONV_DATA(EADC, u32SAMPLECount);
for(g_u32COVNUMFlag = 0; (g_u32COVNUMFlag) < 8; g_u32COVNUMFlag++)
printf("Conversion result of channel %d: 0x%X (%d)\n", (g_u32COVNUMFlag % 4), i32ConversionData[g_u32COVNUMFlag], i32ConversionData[g_u32COVNUMFlag]);
}
else
return ;
}
}