TM4C1294NCPDT: Multiple ADCs with PWM not working properly

Hello Gustavo,

After reviewing the code in full I saw that there were some surprising inconsistencies with what Amit had shared. I think for that specific case it was functional perhaps but I can see why you were having issues with the setup yourself. I went ahead and reworked the code to what I think you need for your own use case. Try this out and see if you are getting your expected results now. I tested with my LaunchPad and got accurate readings on all 4 ADC channels.

Note two key things you need to do!

1) Add uartstdio.c to your project, see this guide on how to do so: https://e2e.ti.com/support/microcontrollers/other/f/908/p/753675/2787705#2787705

2) Add the ADC ISR to your CCS file by using the below line and replace the IntDefaultHandler for ADC Sequence 0 with this ISR.

extern void ADC0Sequence0ISR(void);

Once you have done those, your project should compile. I made a number of changes but I don't think I impacted your PWM setup.

//*****************************************************************************
// Libraries
//*****************************************************************************

#include <stdint.h>
#include <stdbool.h>

#include "driverlib/adc.h"
#include "driverlib/gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/pin_map.h"
#include "driverlib/pwm.h"
#include "driverlib/rom.h"
#include "driverlib/rom_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/timer.h"
#include "driverlib/uart.h"

#include "drivers/pinout.h"

#include "inc/hw_gpio.h"
#include "inc/hw_ints.h"        // Added for the Timer
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_adc.h"
#include "inc/hw_timer.h"
#include "inc/hw_nvic.h"
#include "inc/hw_sysctl.h"

#include "utils/uartstdio.h"

//*****************************************************************************
// Variable Declaration
//*****************************************************************************

// ADC
uint32_t ui32adcValues[4];
volatile bool bDataReady = false;

// PWM
long analogValue = 0, analogAvg = 0, adcToPwmRatio = 0;
uint32_t sumCounter = 0, iSamples = 10000, pwmValue = 0;
uint32_t pwmMax = 24000;        // 120 MHz / 5 kHz

// System
uint32_t g_ui32SysClock;        // System clock rate in Hz.

//*****************************************************************************
//
// The error routine that is called if the driver library encounters an error.
//
//*****************************************************************************
#ifdef DEBUG
void
__error__(char *pcFilename, uint32_t ui32Line)
{
}
#endif

void
ADC0Sequence0ISR(void)
{
	ADCIntClear(ADC0_BASE, 0);

	ADCSequenceDataGet(ADC0_BASE, 0, ui32adcValues);

	if (!bDataReady)
	{
		bDataReady = true;
	}
}

//*****************************************************************************
// ADC Initialization
//*****************************************************************************

void
ConfigureADC(void)
{
	SysCtlPeripheralReset(SYSCTL_PERIPH_GPIOE);
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
	SysCtlPeripheralReset(SYSCTL_PERIPH_ADC0);
	SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
	SysCtlDelay(10);

	GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1 | GPIO_PIN_0 );

	ADCClockConfigSet(ADC0_BASE, ADC_CLOCK_SRC_PLL | ADC_CLOCK_RATE_EIGHTH, 30);

    //
    // Wait for the clock configuration to set.
    //
    SysCtlDelay(10);

	// Choose Sequencer 2 and set it at the highest Priority.
//	ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR,  0);
	ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_ALWAYS,  0);

	ADCSequenceStepConfigure(ADC0_BASE,0,0, ADC_CTL_CH0);
	ADCSequenceStepConfigure(ADC0_BASE,0,1, ADC_CTL_CH1);
	ADCSequenceStepConfigure(ADC0_BASE,0,2, ADC_CTL_CH2);
	ADCSequenceStepConfigure(ADC0_BASE,0,3, ADC_CTL_CH3 | ADC_CTL_IE | ADC_CTL_END);

	ADCSequenceEnable(ADC0_BASE, 0);
	ADCIntClear(ADC0_BASE, 0);
	ADCIntEnable(ADC0_BASE, 0);
	IntEnable(INT_ADC0SS0);
}

//*****************************************************************************
// PWM Initialization - 13.09.2020
//*****************************************************************************
void Init_PWM(){

    // 1.
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);        // Enable Port F
    while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOF));

    // 2.
    SysCtlPWMClockSet(SYSCTL_PWMDIV_16);
    SysCtlPeripheralDisable(SYSCTL_PERIPH_PWM0);
    SysCtlPeripheralReset(SYSCTL_PERIPH_PWM0);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
    while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_PWM0)));


    // PWM0_BASE: 0 -> 0 from M_0_PWM1
    // PWM_OUT_1 and PWM_OUT_1_BIT: 1 from M0PWM_1
    // PWM_GEN_0: GEN_0 for PWM0 and PWM1, GEN_1 for PWM2 and PWM3...


    SysCtlPWMClockSet(SYSCTL_PWMDIV_1);                 // 120 MHz / 1 = 120 MHz

    GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1);        // Pin 1 from PortF - PF1
    GPIOPinConfigure(GPIO_PF1_M0PWM1);
    PWMGenConfigure(PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
    PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, pwmMax);       // 120 MHz / pwmMax = pwmPeriod
    PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, 1);
    PWMGenEnable(PWM0_BASE, PWM_GEN_0);
    PWMOutputState(PWM0_BASE, PWM_OUT_1_BIT, true);

    PWMIntEnable(PWM0_BASE, PWM_INT_GEN_0);
    PWMGenIntTrigEnable(PWM0_BASE, PWM_GEN_0, PWM_TR_CNT_ZERO);
    IntEnable(INT_PWM0_0);

}

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

int
main(void)
{

	//
	// Run from the PLL at 120 MHz.
	//
	g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
			SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
			SYSCTL_CFG_VCO_480), 120000000);

	//
	// Configure the device pins.
	//
	PinoutSet(false, false);

	//
	// 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();

	//
	// Enable the GPIO pins for the LED D1 (PN1).
	//
	ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);

	//
	// Initialize the UART.
	//
	ConfigureADC();
	Init_PWM();

	IntMasterEnable();

	adcToPwmRatio = pwmMax/4095;        // 2^12 bits

	// Infinite loop
	while(1)
	{
		if (bDataReady)
		{
			UARTprintf("AIN0 = %4d\r", ui32adcValues[0]);
			UARTprintf("AIN1 = %4d\r", ui32adcValues[1]);
			UARTprintf("AIN2 = %4d\r", ui32adcValues[2]);
			UARTprintf("AIN3 = %4d\r", ui32adcValues[3]);

			bDataReady = false;
		}

		// Sum filter
		if (sumCounter < iSamples) {

			analogValue = ui32adcValues[0] + analogValue;

			sumCounter++;

		} else {

			analogAvg = analogValue / iSamples;

			// PWM
			pwmValue = analogAvg*adcToPwmRatio;

			// PWM Min Limit
			if (pwmValue < 30) {
				pwmValue = 1;       // pwmValue can never be zero
			}

			// PWM Max Limit
			if (pwmValue > (pwmMax - 30)) {
				pwmValue = pwmMax;
			}

			// Change PWM Value
			PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, pwmValue);

			// Reset Sum Filter Variables
			analogValue = 0;
			sumCounter = 0;
		}
	}
}