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;
}

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
	//}
}

// *******************************************************
// 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);
	}
}

void ADC0IntHandler()
{

    unsigned long adc0Value;   // Holds the ADC result
    char adc0String[5];        // Holds the string-converted ADC result

    // 清ADC0中断标志.
    // ADCIntClear (unsigned long ulBase, unsigned long ulSequenceNum) 
    ADCIntClear(ADC0_BASE, 0);
    
    //从SSO读出转换结果 (FIFO0),本例中只有一个采样.如果要使用多个转换源,需要使用数组做为参数传递给API函数,保存FIFO转换结果.
    // long ADCSequenceDataGet (unsigned long ulBase,unsigned long ulSequenceNum,unsigned long *pulBuffer) 
    ADCSequenceDataGet(ADC0_BASE, 0, &adc0Value);
    adc0Value= ((59960 - (adc0Value * 100)) / 356);
    
    
    // 在OLED上显示当前温度
    usprintf(adc0String, "%d", adc0Value);    
    IntMasterDisable();
    RIT128x96x4StringDraw("Current temp :         ", 6, 48, 15);
    RIT128x96x4StringDraw(adc0String, 94, 48, 15);
    IntMasterEnable();  

    // ADC模块空闲,可以进行下一次转换
    adc_busy=0;    
 
}

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;
	}

/*****************************************************
 * 	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;
	}

}

//******************************************************************************
// The handler for the ADC conversion (height) complete interrupt.
// Writes to the circular buffer.
//*****************************************************************************
void HeightIntHandler(void)
{
	unsigned long ulValue;
	static int counter = 0;      //Keeping track of the buffer count for the initialRead
	int current;
	int sum = 0;
	int i;

	// Clean up, clearing the interrupt
	ADCIntClear(ADC0_BASE, 3);

	// Get the single sample from ADC0. (Yes, I know, I just did what you did sir :p)
	ADCSequenceDataGet(ADC0_BASE, 3, &ulValue);

	// Place it in the circular buffer (advancing write index)
	g_inBuffer.data[g_inBuffer.windex] = (int) ulValue;
	g_inBuffer.windex++;
	if (g_inBuffer.windex >= g_inBuffer.size)
		g_inBuffer.windex = 0;

	if (counter < BUF_SIZE) {
			counter++;
			if (counter == BUF_SIZE) {
				for (i = 0; i < BUF_SIZE; i++) {
					current = ulValue;
					sum = sum + current;
				}
        //Average voltage to calibrate the minimum height of the helicopter
				initialRead = ADC_TO_MILLIS(sum/BUF_SIZE);
			}
		}
}

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

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;
}

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;


	}

}

/**
 * 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
	}
}

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 adc_init(void)
{
    unsigned long ulDummy = 0;

    // Enable the ADC hardware
    SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);

    

    // Configure the pin as analog input
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
    //SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
    GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1); // PIN D3/2/1 as ADC.
    GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_5); // PIN E5 as ADC.
    //GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_5 | GPIO_PIN_4);                           // U_AN{0..1}



    

    // for 6 ADCs
    // use Sample Sequencer 0 since it is the only one able to handle more than four ADCs
    ADCSequenceDisable(ADC0_BASE, 0);
    // configure Sequencer to trigger from processor with priority 0
    ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
    // do NOT use TRIGGER_TIMER because of malfunction in the touch screen handler
    //ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_TIMER, 0);

    // configure the steps of the Sequencer
    ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH4);   //CH4 = PD3  
    ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_CH5);   //CH5 = PD2    
    ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_CTL_CH6);   //CH6 = PD1    
    ADCSequenceStepConfigure(ADC0_BASE, 0, 3, ADC_CTL_CH8 | ADC_CTL_IE | ADC_CTL_END);//CH8 = PE5
    //ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_CH11);                    // U_AN1
    //ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_CTL_CH4);                     // U_AN2
    //ADCSequenceStepConfigure(ADC0_BASE, 0, 3, ADC_CTL_CH5);                     // U_AN3
    //ADCSequenceStepConfigure(ADC0_BASE, 0, 4, ADC_CTL_CH6);                     // U_AN4
    //ADCSequenceStepConfigure(ADC0_BASE, 0, 5, ADC_CTL_CH7 | ADC_CTL_IE | ADC_CTL_END);       // U_AN5
    ADCSequenceEnable(ADC0_BASE, 0);

    // flush the ADC
    ADCSequenceDataGet(ADC0_BASE, 0, &ulDummy);

    // Enable Interrupt for ADC0 Sequencer 0
    ADCIntEnable(ADC0_BASE, 0);
    IntEnable(INT_ADC0);

    /*
   	for (int i=0; i < 4; i++) {
        for (int j=0; j < ADC_BUFF_SIZE; j++) {
            adcBuff[i][j] = 50; //give the buffers a half decent starting value.
        }
    }

    adcBuffCnt = 0;
    */

}

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 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 ADC0_Handler(void){

  // Clear flag
  ADCIntClear(ADC0_BASE, 0);
  
  ADCSequenceDataGet(ADC0_BASE, 0, Buffer);
	
  Status = TRUE;
}

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;
	
}