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