自学教程：C++ ADCProcessorTrigger函数代码示例

// *******************************************************// Takes an ADC sample. This is the location of// the helicopter on the vertical axis.void heightSample(void){	//* we could just read ADC every time we call this	//* not much need to use systick as with yaw??	//* could combine yaw and height ISRs in one.	unsigned long ulValue[10];	//long ulCount = 0;    //    // Trigger the ADC conversion.    ADCProcessorTrigger(ADC0_BASE, 3);    //    // Wait for conversion to be completed.    while(!ADCIntStatus(ADC0_BASE, 3, false))    {    }    // Read ADC Value.    //ulCount = ADCSequenceDataGet(ADC0_BASE, 3, ulValue);    //Strange thing is happening, ADCSequecnceDataGet()    // Regularly returns a value on the order of 10^9    // when the return value is 0 (false).    if (ADCSequenceDataGet(ADC0_BASE, 3, ulValue) == 1)    {    	g_height = ulValue[0];    	writeCircBuf(&g_heightBuf, g_height);    }    // I'm not going to bother taking a new reading because    // one sample is not significant since it is averaged.}

void SampleLightCO(void){		unsigned long ulADC0_Value[1];	SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);	GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_3);	ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);	ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE |	ADC_CTL_END);	ADCSequenceEnable(ADC0_BASE, 3);	ADCIntClear(ADC0_BASE, 3);	while(1){		ADCProcessorTrigger(ADC0_BASE, 3);		while(!ADCIntStatus(ADC0_BASE, 3, false)){		}		ADCIntClear(ADC0_BASE, 3);		ADCSequenceDataGet(ADC0_BASE, 3, ulADC0_Value);				Log("Breath Level = ");		LogD(ulADC0_Value[0]);		Log("/r");		SysCtlDelay(SysCtlClockGet() / 12);	}}

//*****************************************************************************////! /brief  adc api interrupt state and data get test.//!//! /return None.////*****************************************************************************static void adcIntTest(void){	//    // Set the length of converter    //    // ADCConverLenSet(ADC1_BASE, 1, 1);    //    // Test ADC configure API    //    // ADCSequenceIndexSet(ADC1_BASE, ulAdcSeqNo, ulAdcSeqNo);    // ADCSampLenSet(ADC1_BASE, 14, ADC_SAMPTIME_7_5_CYCLE);    //    // A/D interrupt enable     //    ADCIntEnable(ADC_BASE, ADC_INT_END_CONVERSION);    xIntEnable(INT_ADC);    xADCIntCallbackInit(ADC_BASE, ADC0IntFucntion);    //    // A/D configure     //    ADCConfigure(ADC_BASE, ADC_INPUT_SINGLE, ADC_OP_CONTINUOUS, ADC_TRIGGER_PROCESSOR);    ADCProcessorTrigger(ADC_BASE);    TestAssertQBreak("T", "xadc interrupt function error!", 0xFFFFFFFF);}

/***************************************************** * 	Function: checkIntTempSensor *	Description: Reads internal temperature sensor *	Input: NONE *	Output: ui32TempAvg, ui32TempValueC, ui32TempValueF *****************************************************/void checkIntTempSensor(void){	// Clear flag	ADCIntClear(ADC0_BASE, 0);	// Trigger processor	ADCProcessorTrigger(ADC0_BASE, 0);	// Wait for ADC status to be set	while(!ADCIntStatus(ADC0_BASE, 0, false)){}	// Get data and convert to useful values	// Read all four steps of sequence into ui32ADC0Value	ADCSequenceDataGet(ADC0_BASE, 0, ui32ADC0Value);	ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2] + ui32ADC0Value[3] + 2)/4;	ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096)/10;	ui32TempValueF = ((ui32TempValueC * 9) + 160) / 5;	// Shutdown if device is getting too hot	if(ui32TempValueF >= SHUTDOWN_TEMP)	{		mode = SYSTEM_SHUTDOWN;	}}

unsigned int ReadWall_IR () {	uint32_t resultRight, resultFront;	int i;	ADCProcessorTrigger(ADC0_BASE, 2);	//Wait for ADC to finish converting.	for ( i = 10000; i>0; i--);	//delay a bit	ADCSequenceDataGet(ADC0_BASE, 2, &resultRight);	ADCSequenceDataGet(ADC0_BASE, 2, &resultFront);	//Check if the front wall is close.	if (resultFront > MAX_VAL_F){		front_wall_det = 1;	}	else {		front_wall_det = 0;	}	//Check if the right wall is close.	if (resultRight < MIN_VAL_R){		wall_det = 0;	}	else {		wall_det = 1;	}	return resultRight;}

/** * Do a processor A/D conversion sequence. */static void scan_proc_adc(void){	int samples;	/*	 * We occasionally get too many or too few samples because	 * the extra (missing) samples will show up on the next read	 * operation.  Just do it again if this happens.	 */	for (samples = 0; samples != ADC_SAMPLES; ) {		ADCSequenceEnable(ADC0_BASE, 0);		ADCProcessorTrigger(ADC0_BASE, 0);		/*		 * Wait until the sample sequence has completed.		 */		while(!ADCIntStatus(ADC0_BASE, 0, false))			;		/*		 * Read the values from the ADC.  The whole sequence		 * gets converted and stored in one fell swoop.		 */		if (xSemaphoreTake(io_mutex, IO_TIMEOUT)) {			samples = ADCSequenceDataGet(ADC0_BASE, 0,				(unsigned long *)adc_val);			xSemaphoreGive(io_mutex);		}#if (DEBUG > 0)		if (samples != ADC_SAMPLES) {			lprintf("A/D samples: is %d, "				"should be %d./r/n",				samples, ADC_SAMPLES);		}#endif	}}

int setADC (void)	{	unsigned long ulValue;	//char buffer[32] = "";	  //	  // Trigger the sample sequence.	  //	  ADCProcessorTrigger(ADC0_BASE, 0);	  //	  // Wait until the sample sequence has completed.	  //	  while(!ADCIntStatus(ADC0_BASE, 0, false))	  {	  }	  //	  // Read the value from the ADC.	  //	  ADCSequenceDataGet(ADC0_BASE, 0, &ulValue);	  /*debug show value	  RIT128x96x4StringDraw("     ", 90, 88, mainFULL_SCALE);	  itoa(ulValue, buffer, 10 );	  RIT128x96x4StringDraw(buffer, 90, 88, mainFULL_SCALE);	  */    return ulValue;	}

int main(void){    SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);    SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);    GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_5);    GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_5);    ADCSequenceConfigure(ADC0_BASE, 2, ADC_TRIGGER_PROCESSOR, 0);    ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_CH8);    ADCSequenceStepConfigure(ADC0_BASE, 2, 1, ADC_CTL_CH11 | ADC_CTL_IE | ADC_CTL_END);    ADCSequenceEnable(ADC0_BASE, 2);    ADCIntClear(ADC0_BASE, 2);    while(1)    {        ADCProcessorTrigger(ADC0_BASE, 2);        while(!ADCIntStatus(ADC0_BASE, 2, false));        ADCIntClear(ADC0_BASE, 2);        ADCSequenceDataGet(ADC0_BASE, 2, adcValue);        SysCtlDelay(SysCtlClockGet() / 12);    }}

int main(void){	uint32_t ui32ADC0Value[4];	volatile uint32_t ui32TempAvg;	volatile uint32_t ui32TempValueC;	volatile uint32_t ui32TempValueF;	setup();	ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);	ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);	ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);	ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);	ADCSequenceStepConfigure(ADC0_BASE,1,3,ADC_CTL_TS|ADC_CTL_IE|ADC_CTL_END);	ADCSequenceEnable(ADC0_BASE, 1);	while(1)	{		ADCIntClear(ADC0_BASE, 1);		ADCProcessorTrigger(ADC0_BASE, 1);		while(!ADCIntStatus(ADC0_BASE, 1, false))		{		}		ADCSequenceDataGet(ADC0_BASE, 1, ui32ADC0Value);		ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2] + ui32ADC0Value[3] + 2)/4;		ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096)/10;		ui32TempValueF = ((ui32TempValueC * 9) + 160) / 5;	}}

unsigned long ADC_In(unsigned int channelNum){  unsigned long config;  unsigned long data;  // Configuring ADC to start by processor call instead of interrupt  ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);  // Determine input channel  switch(channelNum){    case 0: config = ADC_CTL_CH0; break;	case 1: config = ADC_CTL_CH1; break;	case 2: config = ADC_CTL_CH2; break;	case 3: config = ADC_CTL_CH3; break;  }   // Enable ADC interrupt and last step of sequence  config |= ADC_CTL_IE | ADC_CTL_END;  ADCSequenceStepConfigure(ADC0_BASE, 3, 0, config);  ADCSequenceEnable(ADC0_BASE, 3);  ADCIntClear(ADC0_BASE, 3);  // Start ADC conversion  ADCProcessorTrigger(ADC0_BASE, 3);  // Wait for ADC conversion to finish  while(!ADCIntStatus(ADC0_BASE, 3, false)){}  // Clear interrupt flag and read conversion data  ADCIntClear(ADC0_BASE, 3);  ADCSequenceDataGet(ADC0_BASE, 3, &data);  return data;}

void adc_init_and_run(void){	// Тактирование выбранного модуля АЦП.	SysCtlPeripheralEnable(SYSCTL_PERIPH_ADCx);	// Ожидание готовности выбранного модуля АЦП к настройке.	while(!SysCtlPeripheralReady(SYSCTL_PERIPH_ADCx)) { }	ADCHardwareOversampleConfigure(ADCx_BASE, 4);	// Установка триггера выбранного буфера АЦП.	ADCSequenceConfigure(ADCx_BASE, SSy, ADC_TRIGGER, 0);	ADCSequenceStepConfigure(ADCx_BASE, SSy, 0, ADC_CTL_CH0);	ADCSequenceStepConfigure(		ADCx_BASE, SSy, 1, ADC_CTL_CH1|ADC_CTL_IE|ADC_CTL_END	);	ADCIntClear(ADCx_BASE, SSy);	IntEnable(INT_ADCxSSy);	IntPrioritySet(INT_ADCxSSy, 1);	ADCSequenceEnable(ADCx_BASE, SSy);	ADCProcessorTrigger(ADCx_BASE, SSy);}

long readRightIRSensor (void) {	unsigned long ADCValue = 0;	ADCProcessorTrigger(ADC_BASE, 2 ); 	while(!ADCIntStatus(ADC_BASE, 2, false)); 	ADCSequenceDataGet(ADC_BASE, 2, &ADCValue);	return ADCValue;}

void UARTIntHandler() {	uint32_t ui32Status;	uint32_t ui32ADC0Value[4]; 			// ADC FIFO	volatile uint32_t ui32TempAvg; 		// Store average	volatile uint32_t ui32TempValueC; 	// Temp in C	volatile uint32_t ui32TempValueF; 	// Temp in F	ui32Status = UARTIntStatus(UART0_BASE, true); //get interrupt status	UARTIntClear(UART0_BASE, ui32Status); //clear the asserted interrupts	ADCIntClear(ADC0_BASE, 2); 			// Clear ADC0 interrupt flag.	ADCProcessorTrigger(ADC0_BASE, 2); 	// Trigger ADC conversion.	while (!ADCIntStatus(ADC0_BASE, 2, false))		; 	// wait for conversion to complete.	ADCSequenceDataGet(ADC0_BASE, 2, ui32ADC0Value); 	// get converted data.	// Average read values, and round.	// Each Value in the array is the result of the mean of 64 samples.	ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2]			+ ui32ADC0Value[3] + 2) / 4;	ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096) / 10; // calc temp in C	ui32TempValueF = ((ui32TempValueC * 9) + 160) / 5;	//while(UARTCharsAvail(UART0_BASE)) //loop while there are chars	//{	//  UARTCharPutNonBlocking(UART0_BASE, UARTCharGetNonBlocking(UART0_BASE)); //echo character	GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2); //blink LED	SysCtlDelay(SysCtlClockGet() / (1000 * 3)); //delay ~1 msec	GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0); //turn off LED	//}}

long getADCValue(void) {	unsigned long ADCValue = 0;	ADCProcessorTrigger(ADC_BASE, 0 ); 	while(!ADCIntStatus(ADC_BASE, 0, false)); 	ADCSequenceDataGet(ADC_BASE, 0, &ADCValue);	return ADCValue;}

long getADCValues(int port) {	unsigned long ADCValue[4] = {0,0,0,0};	ADCIntClear(ADC_BASE, port);  ADCProcessorTrigger(ADC_BASE, port); 	while(!ADCIntStatus(ADC_BASE, port, false)); 	ADCSequenceDataGet(ADC_BASE, port, ADCValue);	return ADCValue[0];}

long sampleAdcPort(int port) {	unsigned long ADCValues[4] = {0};	ADCProcessorTrigger(ADC_BASE, 0 ); 	while(!ADCIntStatus(ADC_BASE, 0, false)); 	ADCSequenceDataGet(ADC_BASE, 0, ADCValues);	ADCIntClear(ADC_BASE, 0);	return ADCValues[port];}

void SysTickIntHandler(void){    // Initiate a conversion    ADCProcessorTrigger(ADC0_BASE, 3);    //Polls display on UART0 and Counter For interrupts    g_ulSampCnt++;}

void mode1()	//Obtain samples from ADC{	ADCProcessorTrigger(ADC0_BASE, 2);		// Start Sampling	while(!ADCIntStatus(ADC0_BASE, 2, false));	// Wait until sampling is done	ADCIntClear(ADC0_BASE, 2);	//Clear Interrupt	ADCSequenceDataGet(ADC0_BASE, 2, adcValue);	//Obtain the sample	ssdset(adcValue[0]);}

void Init_ADC() {	SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC);	SysCtlADCSpeedSet(SYSCTL_ADCSPEED_500KSPS);	ADCSequenceConfigure(ADC_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);	ADCSequenceStepConfigure(ADC_BASE, 0, 0, ADC_CTL_IE | ADC_CTL_END | ADC_CTL_CH0);	ADCSequenceEnable(ADC_BASE, 0);	ADCProcessorTrigger(ADC_BASE, 0);}

rt_uint32_t read_battert_adc_value(){	uint32_t battertValue;	ADCProcessorTrigger(ADC0_BASE, 3);	while(!ADCIntStatus(ADC0_BASE, 3, false));	ADCSequenceDataGet(ADC0_BASE, 3, &battertValue);	return battertValue;	}

//*****************************************************************************////! Ininite the ADC //!//! /param None//!//! This function ininite the ADC including clock source and enable ADC //!//! /return none////*****************************************************************************void ADConvert(void){      unsigned long ulAdcSeqNo[] = {0};    xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);    xSysCtlDelay(10000);    xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);    //    // configure GPIO pin as ADC function    //    xSPinTypeADC(ADC0, PA0);    //    // Reset ADC     //    xSysCtlPeripheralReset(xSYSCTL_PERIPH_ADC1);    //    // Set ADC clock source    //    xSysCtlPeripheralClockSourceSet(xSYSCTL_ADC0_MAIN, 4);    //    // Enable ADC clock     //    xSysCtlPeripheralEnable(xSYSCTL_PERIPH_ADC1);     //    // Set the length of converter    //    ADCConverLenSet(ADC1_BASE, 1, 1);    //    // Set the Index of converter Sequence    //    ADCSequenceIndexSet(ADC1_BASE, ulAdcSeqNo, ulAdcSeqNo);    ADCSampLenSet(ADC1_BASE, 0, 128);    //    // A/D interrupt enable     //    ADCIntEnable(ADC1_BASE, ADC_INT_END_CONVERSION);    xIntEnable(xINT_ADC0);    xADCIntCallbackInit(ADC1_BASE, ADC0IntFucntion);    //    // Software trigger enable    //    ADCProcessorTrigger(ADC1_BASE);    //    // A/D configure     //    ADCRegularConfigure(ADC1_BASE, ADC_OP_SINGLE, ADC_TRIGGER_PROCESSOR);    ADCDataRegularGet(ADC1_BASE, ADC_MODE_NORMAL);}

void ADCIntHandler(void) {    while(!ADCIntStatus(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM, false));    ADCIntClear(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM);    xSemaphoreTakeFromISR(adc_mutex, pdFALSE);    ADCSequenceDataGet(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM, adc_vals);    xSemaphoreGiveFromISR(adc_mutex, pdTRUE);    ADCProcessorTrigger(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM);}

void adc_read() {    ADCProcessorTrigger(ADC0_BASE, 0);    while(!ADCIntStatus(ADC0_BASE, 0, false));    ADCIntClear(ADC0_BASE, 0);    ADCSequenceDataGet(ADC0_BASE, 0, ulADC0_Value);    ADCSequenceEnable(ADC0_BASE, 0);}

void get_temp(void){	ADCIntClear(ADC0_BASE, 1);	ADCProcessorTrigger(ADC0_BASE, 1);	while(!ADCIntStatus(ADC0_BASE, 1, false))	{	}	ADCSequenceDataGet(ADC0_BASE, 1, ui32ADC0Value);	ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2] + ui32ADC0Value[3] + 2)/4;	ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096)/10;}

int main(void) {	settemp = 25;	uint32_t ui32ADC0Value[4];	SysCtlClockSet(			SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN					| SYSCTL_XTAL_16MHZ);	SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);	SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);	ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);	ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);	ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);	ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);	ADCSequenceStepConfigure(ADC0_BASE,1,3,ADC_CTL_TS|ADC_CTL_IE|ADC_CTL_END);	ADCSequenceEnable(ADC0_BASE, 1);	GPIOPinConfigure(GPIO_PA0_U0RX);	GPIOPinConfigure(GPIO_PA1_U0TX);	GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);	GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);	UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,			(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));	IntMasterEnable();	IntEnable(INT_UART0);	UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);	while(1){		ADCIntClear(ADC0_BASE, 1);		ADCProcessorTrigger(ADC0_BASE, 1);		while(!ADCIntStatus(ADC0_BASE, 1, false))		{		}		ADCSequenceDataGet(ADC0_BASE, 1, ui32ADC0Value);		ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2] + ui32ADC0Value[3] + 2)/4;		ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096)/10;		ui32TempValueF = ((ui32TempValueC * 9) + 160) / 5;		char m[] = "Current Temperature is    *C, Set Temperature is    *C";		m[23]=(ui32TempValueC/10 % 10) + '0';		m[24]=(ui32TempValueC%10) + '0';		m[49]=(settemp/10 % 10) + '0';		m[50]=(settemp%10) + '0';		int i;		for(i=0;m[i];i++){			UARTCharPut(UART0_BASE, m[i]);		}		if(ui32TempValueC < settemp){			GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,8);		}		else{			GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,2);		}		UARTCharPut(UART0_BASE, '/r');		UARTCharPut(UART0_BASE, '/n');		SysCtlDelay(1000000);	}}

extern "C" void ADC0IntHandler(void) // NOT started yet !!!!		{	uint32_t ui32ADC0Value[4]; //used for storing data from ADC FIFO, must be as large as the FIFO for sequencer in use. Sequencer 1 has FIFO depth of 4	//variables that cannot be optimized out by compiler	ADCIntClear(ADC0_BASE, 1); //clear interrupt flag	ADCSequenceDataGet(ADC0_BASE, 1, ui32ADC0Value);	ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2]			+ ui32ADC0Value[3] + 2) / 4; //calculate average	ADCProcessorTrigger(ADC0_BASE, 1);}

float Board::getTemp() {	float ulTemp_ValueC;	unsigned long gt;	ADCProcessorTrigger(ADC0_BASE, 3);	ADCSequenceDataGet(ADC0_BASE, 3, &gt);	// Berechnung	ulTemp_ValueC = ((1475 * 1023) - (2250 * gt)) / 10230;	return ulTemp_ValueC/10000;}

void Handler2() {	TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT);	ADCProcessorTrigger(ADC_BASE, 0);	while (!ADCIntStatus(ADC_BASE, 0, false));	ADCSequenceDataGet(ADC_BASE, 0, &ADC_resultValue);	pwm = ((double) 400 / 1024) * ADC_resultValue;	usnprintf(buffer, BUFFSIZE, "ADC : %d/n", (int)ADC_resultValue);	UARTPrint0((unsigned char *) buffer);}

void CapacitorTask(void* pvParameter){	unsigned long ulValue=0;	int i=0;	cqueue = xQueueCreate(100,sizeof(unsigned long));	//SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);	GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_1);	GPIOPadConfigSet(GPIO_PORTD_BASE, GPIO_PIN_1, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_OD);	GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_1, 0x02);//Setting the Pin 0 to "high"	//Initialize the ADC using functions from the Stellaris API	//SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);	ADCSequenceConfigure(ADC_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);	ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_IE|ADC_CTL_END|ADC_CTL_CH1);	ADCSequenceEnable(ADC0_BASE, 1);	//ADCIntEnable(ADC0_BASE, 1);	ADCIntClear(ADC0_BASE, 1);	//Trigger from the Processor	while(true)	{		if(flagcap==1)		{			GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_1, 0x00);//Setting the Pin 0 to "high"			vTaskDelay(TICK_R*0.5);			GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_1, 0x02);//Setting the Pin 0 to "high"			i=0;			flagcap = 0;			//ADCIntClear(ADC0_BASE, 1);			while(i<100)			{				ADCProcessorTrigger(ADC0_BASE, 1);				while(!ADCIntStatus(ADC0_BASE, 1, false))				{				}				ADCSequenceDataGet(ADC0_BASE, 1, &ulValue);//Enable ADC sequence 0				ADCIntClear(ADC0_BASE, 1);				xQueueSend(cqueue, &ulValue, 0);				i++;				vTaskDelay(TICK_R*1.0);			}			flagUART = 1;		}		vTaskDelay(TICK_R*10);	}}