This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

关于TM4C129系列 的ADC8个以上多通道数据采集问题

您好,我已经知道了8个通道数据采集,我用的CPU是TM4C1294NCPDT,我需要用14个AI采集通道,但是后面的6个通道怎样配置呢?谢谢

  • 这个芯片是有20个通道,是足够用。配置方法是一样的。可以参考此例程

    //*****************************************************************************
    //
    // single_ended.c - Example demonstrating how to configure the ADC for
    // single ended operation.
    //
    // Copyright (c) 2010-2015 Texas Instruments Incorporated. All rights reserved.
    // Software License Agreement
    //
    // 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.
    //
    // This is part of revision 2.1.1.71 of the Tiva Firmware Development Package.
    //
    //*****************************************************************************

    #include <stdbool.h>
    #include <stdint.h>
    #include "inc/hw_memmap.h"
    #include "driverlib/adc.h"
    #include "driverlib/gpio.h"
    #include "driverlib/pin_map.h"
    #include "driverlib/sysctl.h"
    #include "driverlib/uart.h"
    #include "utils/uartstdio.h"

    //*****************************************************************************
    //
    //! \addtogroup adc_examples_list
    //! <h1>Single Ended ADC (single_ended)</h1>
    //!
    //! This example shows how to setup ADC0 as a single ended input and take a
    //! single sample on AIN0/PE7.
    //!
    //! This example uses the following peripherals and I/O signals. You must
    //! review these and change as needed for your own board:
    //! - ADC0 peripheral
    //! - GPIO Port E peripheral (for AIN0 pin)
    //! - AIN0 - PE7
    //!
    //! The following UART signals are configured only for displaying console
    //! messages for this example. These are not required for operation of the
    //! ADC.
    //! - UART0 peripheral
    //! - GPIO Port A peripheral (for UART0 pins)
    //! - UART0RX - PA0
    //! - UART0TX - PA1
    //!
    //! This example uses the following interrupt handlers. To use this example
    //! in your own application you must add these interrupt handlers to your
    //! vector table.
    //! - None.
    //
    //*****************************************************************************

    //*****************************************************************************
    //
    // This function sets up UART0 to be used for a console to display information
    // as the example is running.
    //
    //*****************************************************************************
    void
    InitConsole(void)
    {
    //
    // Enable GPIO port A which is used for UART0 pins.
    // TODO: change this to whichever GPIO port you are using.
    //
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

    //
    // Configure the pin muxing for UART0 functions on port A0 and A1.
    // This step is not necessary if your part does not support pin muxing.
    // TODO: change this to select the port/pin you are using.
    //
    GPIOPinConfigure(GPIO_PA0_U0RX);
    GPIOPinConfigure(GPIO_PA1_U0TX);

    //
    // Enable UART0 so that we can configure the clock.
    //
    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

    //
    // Use the internal 16MHz oscillator as the UART clock source.
    //
    UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);

    //
    // Select the alternate (UART) function for these pins.
    // TODO: change this to select the port/pin you are using.
    //
    GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

    //
    // Initialize the UART for console I/O.
    //
    UARTStdioConfig(0, 115200, 16000000);
    }

    //*****************************************************************************
    //
    // Configure ADC0 for a single-ended input and a single sample. Once the
    // sample is ready, an interrupt flag will be set. Using a polling method,
    // the data will be read then displayed on the console via UART0.
    //
    //*****************************************************************************
    int
    main(void)
    {
    #if defined(TARGET_IS_TM4C129_RA0) || \
    defined(TARGET_IS_TM4C129_RA1) || \
    defined(TARGET_IS_TM4C129_RA2)
    uint32_t ui32SysClock;
    #endif

    //
    // This array is used for storing the data read from the ADC FIFO. It
    // must be as large as the FIFO for the sequencer in use. This example
    // uses sequence 3 which has a FIFO depth of 1. If another sequence
    // was used with a deeper FIFO, then the array size must be changed.
    //
    uint32_t pui32ADC0Value[1];

    //
    // Set the clocking to run at 20 MHz (200 MHz / 10) using the PLL. When
    // using the ADC, you must either use the PLL or supply a 16 MHz clock
    // source.
    // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the
    // crystal on your board.
    //
    #if defined(TARGET_IS_TM4C129_RA0) || \
    defined(TARGET_IS_TM4C129_RA1) || \
    defined(TARGET_IS_TM4C129_RA2)
    ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
    SYSCTL_OSC_MAIN |
    SYSCTL_USE_PLL |
    SYSCTL_CFG_VCO_480), 20000000);
    #else
    SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
    SYSCTL_XTAL_16MHZ);
    #endif

    //
    // Set up the serial console to use for displaying messages. This is
    // just for this example program and is not needed for ADC operation.
    //
    InitConsole();

    //
    // Display the setup on the console.
    //
    UARTprintf("ADC ->\n");
    UARTprintf(" Type: Single Ended\n");
    UARTprintf(" Samples: One\n");
    UARTprintf(" Update Rate: 250ms\n");
    UARTprintf(" Input Pin: AIN0/PE7\n\n");

    //
    // The ADC0 peripheral must be enabled for use.
    //
    SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);

    //
    // For this example ADC0 is used with AIN0 on port E7.
    // The actual port and pins used may be different on your part, consult
    // the data sheet for more information. GPIO port E needs to be enabled
    // so these pins can be used.
    // TODO: change this to whichever GPIO port you are using.
    //
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);

    //
    // Select the analog ADC function for these pins.
    // Consult the data sheet to see which functions are allocated per pin.
    // TODO: change this to select the port/pin you are using.
    //
    GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_7);

    //
    // Enable sample sequence 3 with a processor signal trigger. Sequence 3
    // will do a single sample when the processor sends a signal to start the
    // conversion. Each ADC module has 4 programmable sequences, sequence 0
    // to sequence 3. This example is arbitrarily using sequence 3.
    //
    ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);

    //
    // Configure step 0 on sequence 3. Sample channel 0 (ADC_CTL_CH0) in
    // single-ended mode (default) and configure the interrupt flag
    // (ADC_CTL_IE) to be set when the sample is done. Tell the ADC logic
    // that this is the last conversion on sequence 3 (ADC_CTL_END). Sequence
    // 3 has only one programmable step. Sequence 1 and 2 have 4 steps, and
    // sequence 0 has 8 programmable steps. Since we are only doing a single
    // conversion using sequence 3 we will only configure step 0. For more
    // information on the ADC sequences and steps, reference the datasheet.
    //
    ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE |
    ADC_CTL_END);

    //
    // Since sample sequence 3 is now configured, it must be enabled.
    //
    ADCSequenceEnable(ADC0_BASE, 3);

    //
    // Clear the interrupt status flag. This is done to make sure the
    // interrupt flag is cleared before we sample.
    //
    ADCIntClear(ADC0_BASE, 3);

    //
    // Sample AIN0 forever. Display the value on the console.
    //
    while(1)
    {
    //
    // Trigger the ADC conversion.
    //
    ADCProcessorTrigger(ADC0_BASE, 3);

    //
    // Wait for conversion to be completed.
    //
    while(!ADCIntStatus(ADC0_BASE, 3, false))
    {
    }

    //
    // Clear the ADC interrupt flag.
    //
    ADCIntClear(ADC0_BASE, 3);

    //
    // Read ADC Value.
    //
    ADCSequenceDataGet(ADC0_BASE, 3, pui32ADC0Value);

    //
    // Display the AIN0 (PE7) digital value on the console.
    //
    UARTprintf("AIN0 = %4d\r", pui32ADC0Value[0]);

    //
    // This function provides a means of generating a constant length
    // delay. The function delay (in cycles) = 3 * parameter. Delay
    // 250ms arbitrarily.
    //
    #if defined(TARGET_IS_TM4C129_RA0) || \
    defined(TARGET_IS_TM4C129_RA1) || \
    defined(TARGET_IS_TM4C129_RA2)
    SysCtlDelay(ui32SysClock / 12);
    #else
    SysCtlDelay(SysCtlClockGet() / 12);
    #endif
    }
    }

  • 非常感谢您的耐心解答,但是我还有疑问,我的程序是这样的,如下:

    uint32_t     ADC_Value[10]={0};    //需要采集10个通道ADC数据

        SysClock = MAP_SysCtlClockFreqSet(
                    (SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480),
                    25000000);
        
        
      /*uint32_t SysCtlClockGet(void)*/
        /*SysCtlDelay*/
        /*SysCtlPWMClockSet(unsigned long ulConfig)*/
        /*   */
        
        MAP_SysTickDisable();
        MAP_SysTickPeriodSet(SysClock/ RT_TICK_PER_SECOND - 1);
        MAP_SysTickIntEnable();
        MAP_SysTickEnable();    

        return 0;
    }
    // rt_hw_cpu_init should be run before any other INIT_BOARD_EXPORT
    // We use INIT_EXPORT here and set the sequence index to "0.xxxx"
    INIT_EXPORT(rt_hw_cpu_init, "0.post");

    int ADC_Init(void)
    {
        //PK2,3,1  ->  ADC0-2 ,  AIN18,19,17
        MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
        MAP_GPIOPinTypeADC(GPIO_PORTK_BASE,  GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
        //PE0,2,4 ->  ADC3,4,9,  AIN3,1,9
        MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
        MAP_GPIOPinTypeADC(GPIO_PORTE_BASE,  GPIO_PIN_0 | GPIO_PIN_2 | GPIO_PIN_4);
        //PD2,0,6,4  ->  ADC5,6,7,8,  AIN13,15,5,7
        MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
        MAP_GPIOPinTypeADC(GPIO_PORTD_BASE,  GPIO_PIN_0 | GPIO_PIN_2 | GPIO_PIN_4| GPIO_PIN_6);    
        //PE4 ->  ADC9,  AIN9
                    //PE4 ->  ADC9,  AIN9
        MAP_GPIOPinTypeADC(GPIO_PORTE_BASE,  GPIO_PIN_4);    
        

        MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
        MAP_ADCReferenceSet(ADC0_BASE,ADC_REF_INT);
        ADCClockConfigSet(ADC0_BASE, ADC_CLOCK_SRC_MOSC | ADC_CLOCK_RATE_FULL, 0);//25MHz
    //    ADCClockConfigGet( ADC0_BASE, *pui32ClockDiv)
    //extern void ADCSequenceStepConfigure(uint32_t ui32Base, uint32_t ui32SequenceNum,
                                         uint32_t ui32Step, uint32_t ui32Config);  

    //选择ADC0,ui32SequenceNum=0,则有0-7 8个通道,经测试8个通道有数据
        MAP_ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);


    //  前8个通道有数据
        MAP_ADCSequenceStepConfigure(ADC0_BASE,0,0,ADC_CTL_CH18);
        MAP_ADCSequenceStepConfigure(ADC0_BASE,0,1,ADC_CTL_CH19);
        MAP_ADCSequenceStepConfigure(ADC0_BASE,0,2,ADC_CTL_CH17);
        MAP_ADCSequenceStepConfigure(ADC0_BASE,0,3,ADC_CTL_CH3);
        MAP_ADCSequenceStepConfigure(ADC0_BASE,0,4,ADC_CTL_CH1);

        MAP_ADCSequenceStepConfigure(ADC0_BASE,0,5,ADC_CTL_CH13);
        MAP_ADCSequenceStepConfigure(ADC0_BASE,0,6,ADC_CTL_CH15);  
        MAP_ADCSequenceStepConfigure(ADC0_BASE,0,7,ADC_CTL_CH5);
        
        // 后2个通道没数据,令后面2个通道ui32SequenceNum=1, ui32Step=0,1,不成功

        //令后面2个通道 为ADC1 ui32SequenceNum=1, ui32Step=0,1,不成功
        MAP_ADCSequenceStepConfigure(ADC0_BASE,0,8,ADC_CTL_CH7);
        MAP_ADCSequenceStepConfigure(ADC0_BASE,0,9,ADC_CTL_CH9|ADC_CTL_END);
        
    //    MAP_ADCSequenceStepConfigure(ADC0_BASE,1,2,ADC_CTL_CH19|ADC_CTL_END);
        
        MAP_ADCHardwareOversampleConfigure(ADC0_BASE,16);

        MAP_ADCSequenceEnable(ADC0_BASE, 0);
        
        return 0;
    }

    所以只好求助