CCS/MSP432P401R: Sync PWM1 (TimerA0) and PWM2 (TimerA1)

Bob,

Thanks for the clarifications, I understood about the timing between 2 different timers, I will do the project adjustment and I will work on the same timer.

About PWM generation (compare_multiple_pwm) I do not see how I can vary the Phase Shifted between the two PWM signals. You can explaning for me?

Thank you.

In its code, CCR3 and CCR4 do not change the PWM. Only the Value of CCR1 and CCR2 are required to generate the same signal. Am I doing something wrong?

Follow the complete code and result Image-1.

/* DriverLib Includes */
#include <ti/devices/msp432p4xx/driverlib/driverlib.h>

/* Application Defines */
#define PERIOD    1000
#define PWM1PHASE  100
#define PWM1DUTYC  100
#define PWM2OFFSET 250
#define PWM2DUTYC  100

/* Timer_A UpMode Configuration Parameter */
Timer_A_UpModeConfig upConfig =
{
        TIMER_A_CLOCKSOURCE_SMCLK,                    // SMCLK Clock Source
        TIMER_A_CLOCKSOURCE_DIVIDER_1,              // SMCLK/1 = 3MHz
        PERIOD,                                                                  // 5000 tick period
        TIMER_A_TAIE_INTERRUPT_DISABLE,               // Disable Timer interrupt
        TIMER_A_CCIE_CCR0_INTERRUPT_ENABLE ,  // Enable CCR0 interrupt
        TIMER_A_DO_CLEAR                                            // Clear value
};

const Timer_A_CompareModeConfig compareConfig_PWM1LH = {
  TIMER_A_CAPTURECOMPARE_REGISTER_1,                                      // Use CCR1
  TIMER_A_CAPTURECOMPARE_INTERRUPT_DISABLE,                      // Disable CCR interrupt
  TIMER_A_OUTPUTMODE_TOGGLE_SET,                                              // Set
  PWM1PHASE                                                                                             // LH edge at this point in the cycle
};

const Timer_A_CompareModeConfig compareConfig_PWM1HL = {
  TIMER_A_CAPTURECOMPARE_REGISTER_2,                                     // Use CCR2
  TIMER_A_CAPTURECOMPARE_INTERRUPT_DISABLE,                     // Disable CCR interrupt
  TIMER_A_OUTPUTMODE_TOGGLE_RESET,                                        // Reset
  PWM1PHASE + PWM1DUTYC                                                                // HL edge at this point in the cycle
};

const Timer_A_CompareModeConfig compareConfig_PWM2LH = {
  TIMER_A_CAPTURECOMPARE_REGISTER_3,                                     // Use CCR3
  TIMER_A_CAPTURECOMPARE_INTERRUPT_DISABLE,                     // Disable CCR interrupt
  TIMER_A_OUTPUTMODE_TOGGLE_SET,                                             // Set
  PWM1PHASE + PWM2OFFSET                                                              // LH edge at this point in the cycle
};

const Timer_A_CompareModeConfig compareConfig_PWM2HL = {
  TIMER_A_CAPTURECOMPARE_REGISTER_4,                                    // Use CCR4
  TIMER_A_CAPTURECOMPARE_INTERRUPT_DISABLE,                    // Disable CCR interrupt
  TIMER_A_OUTPUTMODE_TOGGLE_RESET,                                       // Reset
  PWM1PHASE + PWM2OFFSET + PWM2DUTYC                                  // HL edge at this point in the cycle
};


int main(void)
{
    /* Stop WDT  */
    MAP_WDT_A_holdTimer();

    /* Setting P7.7 and P7.6 and peripheral outputs for CCR */
    MAP_GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P7,
            GPIO_PIN6 + GPIO_PIN7, GPIO_PRIMARY_MODULE_FUNCTION);

    /* Configuring Timer_A1 for UpDown Mode and starting counter */
    MAP_Timer_A_configureUpMode(TIMER_A1_BASE, &upConfig);
    MAP_Timer_A_startCounter(TIMER_A1_BASE, TIMER_A_UP_MODE);


    /* Initialize compare registers to generate PWM1,2 */
    MAP_Timer_A_initCompare(TIMER_A1_BASE, &compareConfig_PWM1LH);
    MAP_Timer_A_initCompare(TIMER_A1_BASE, &compareConfig_PWM1HL);
    MAP_Timer_A_initCompare(TIMER_A1_BASE, &compareConfig_PWM2LH);
    MAP_Timer_A_initCompare(TIMER_A1_BASE, &compareConfig_PWM2HL);

    /* Sleeping when not in use */
    while (1)
    {
        MAP_PCM_gotoLPM0();
    }
}

The result:

I understand the risks of not having "dead time", anyway thank you for letting me know! In my application I do not have this problem. Actually I need activate the two PWMs together sometimes. These Signals are used to trigger from image capture cameras.These signals are used to trigger image capture cameras.

I've tried using several methods to generate these lagged signals between them, but so far I have not been able to.

Thanks for your help!

I thought and found a way in which I can make the PWM offset. But now I can not get a faster pulse. I am using 48Mhz in the CS_MCLK which is used by Timer32 which generates the interrupt. But I need to work on very high frequencies in the range of 10Mhz. And so far I've only been able to generate a 100kHz wave.

If anyone can parse the code, I'm grateful!

/* 
 * MSP432 UART - PC Echo with 48MHz BRCLK
 *
 * Description: This demo echoes back characters received via a PC serial port.
 * SMCLK/DCO is used as a clock source and the device is put in LPM0
 * The auto-clock enable feature is used by the eUSCI and SMCLK is turned off
 * when the UART is idle and turned on when a receive edge is detected.
 * Note that level shifter hardware is needed to shift between RS232 and MSP
 * voltage levels.
 *
 *                 MSP432P401
 *             -----------------
 *            |                 |
 *            |           P1.1  |<----Toggle Switch
 *            |           P2.6  |----> Output PWM1
 *       RST -|           P2.4  |----> Output PWM2
 *            |                 |
 *            |     P1.3/UCA0TXD|----> PC (echo)
 *            |     P1.2/UCA0RXD|<---- PC
 *            |                 |
 *
*/
/* DriverLib Includes */
#include <ti/devices/msp432p4xx/driverlib/driverlib.h>

/* Standard Includes */
#include <stdint.h>
#include <stdbool.h>

#define TIMER_PERIOD 1

//!*******************[Simple UART Config]*******************************
/* UART Configuration Parameter. These are the configuration parameters to
 * make the eUSCI A UART module to operate with a 9600 baud rate. These
 * values were calculated using the online calculator that TI provides
 * at:
 *software-dl.ti.com/.../index.html
 */
const eUSCI_UART_Config uartConfig =
{
        EUSCI_A_UART_CLOCKSOURCE_SMCLK,                 // SMCLK Clock Source
        312,                                            // BRDIV = 13
        8,                                              // UCxBRF = 0
        0,                                              // UCxBRS = 37
        EUSCI_A_UART_NO_PARITY,                         // No Parity
        EUSCI_A_UART_LSB_FIRST,                         // LSB First
        EUSCI_A_UART_ONE_STOP_BIT,                      // One stop bit
        EUSCI_A_UART_MODE,                              // UART mode
        EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION   // Oversampling
};
//!*******************[Simple UART Config]*******************************

//Declaração de Operadores Globais
        char matriz1[7] = {0, 0, 0, 0, 0, 0, 0};
        int Cont = 0;

        int pwm1[10] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
        int index_pwm1 = 0;
        int laststatusOUT1 = 0;

        int pwm2[10] = {0, 0, 0, 0, 0, 1, 0, 0, 0, 0};
        int index_pwm2 = 0;
        int laststatusOUT2 = 0;

        int test = 0;



int main(void)
{
    /* Halting WDT  */
    MAP_WDT_A_holdTimer();

    /* Configuring GPIO */
    MAP_GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
    MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);

    /* Selecting P1.2 and P1.3 in UART mode */
    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
            GPIO_PIN1 | GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);

        //![Simple CS Config]
        /* Configuring pins for peripheral/crystal usage and LED for output */
        MAP_GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_PJ,
                GPIO_PIN3 | GPIO_PIN2, GPIO_PRIMARY_MODULE_FUNCTION);
        /* Just in case the user wants to use the getACLK, getMCLK, etc. functions,
         * let's set the clock frequency in the code.
         */
        CS_setExternalClockSourceFrequency(48000000,48000000);
        /* Starting HFXT in non-bypass mode without a timeout. Before we start
         * we have to change VCORE to 1 to support the 48MHz frequency */
        MAP_PCM_setCoreVoltageLevel(PCM_VCORE1);
        MAP_FlashCtl_setWaitState(FLASH_BANK0, 2);
        MAP_FlashCtl_setWaitState(FLASH_BANK1, 2);
        CS_startHFXT(false);

        /* Initializing MCLK to HFXT (effectively 48MHz) */
        MAP_CS_initClockSignal(CS_MCLK, CS_HFXTCLK_SELECT, CS_CLOCK_DIVIDER_1);
        //![Simple CS Config]


        /* Configuring Timer32 to 128000 (1s) of MCLK in periodic mode */
        MAP_Timer32_initModule(TIMER32_BASE, TIMER32_PRESCALER_1, TIMER32_32BIT,
                                   TIMER32_PERIODIC_MODE);


    /* Configuring GPIO2.4 as peripheral output for PWM  and P1.1 for button
     * interrupt */
    //Output
    MAP_GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN6);
    MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN6);

    MAP_GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN4);
    MAP_GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN4);
    //Input
    MAP_GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN1);
    MAP_GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1);
    MAP_GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN1);

    //![Simple UART Example]
    /* Configuring UART Module */
    MAP_UART_initModule(EUSCI_A0_BASE, &uartConfig);

    /* Enable UART module */
    MAP_UART_enableModule(EUSCI_A0_BASE);

    /* Enabling interrupts */
    MAP_UART_enableInterrupt(EUSCI_A0_BASE, EUSCI_A_UART_RECEIVE_INTERRUPT);
    MAP_Interrupt_enableInterrupt(INT_EUSCIA0);                                 //Permite a Inicialização da interrupção da comunicação UART
    MAP_Interrupt_enableInterrupt(INT_PORT1);
    MAP_Interrupt_enableMaster();   

    /* Enabling interrupts */
    MAP_Interrupt_enableInterrupt(INT_T32_INT1);

    MAP_Timer32_setCount(TIMER32_BASE,TIMER_PERIOD);
    MAP_Timer32_enableInterrupt(TIMER32_BASE);
    MAP_Timer32_startTimer(TIMER32_BASE, false);

    /* Starting the Timer_A1 */
    MAP_Timer_A_startCounter(TIMER_A1_BASE, TIMER_A_UP_MODE);

    while(true)                                                             //Rotina principal
    {
        test = CS_getSMCLK();
    }
}



void PORT1_IRQHandler(void)                                                 //Interrupção de acionamento da Chave P1.1
{
    uint32_t status = MAP_GPIO_getEnabledInterruptStatus(GPIO_PORT_P1);
    MAP_GPIO_clearInterruptFlag(GPIO_PORT_P1, status);
        CS_initClockSignal(CS_SMCLK, CS_DCOCLK_SELECT, 2);
        test = CS_getSMCLK();
    MAP_UART_transmitData(EUSCI_A0_BASE, 0xff);
}

/* EUSCI A0 UART ISR - Echoes data back to PC host */
void EUSCIA0_IRQHandler(void)                                               //Interrupção acionada quando recebe valor em "MAP_UART_receiveData(EUSCI_A0_BASE)"
{
    uint32_t status = MAP_UART_getEnabledInterruptStatus(EUSCI_A0_BASE);    //Gera uma variável local chamada status que recebe 1 quando a interrupção foi chamana
    uint32_t TXdata = 0x00;                                                 //Gera uma variável local chamada TXdata que recebe 0

    TXdata = MAP_UART_receiveData(EUSCI_A0_BASE);                           //Coloca o dado recebido da comunicação UART pelo "MAP_UART_receiveData(EUSCI_A0_BASE)" em TXdata

    MAP_UART_clearInterruptFlag(EUSCI_A0_BASE, status);                     //Limpa o status flag da interrupção
    if(status & EUSCI_A_UART_RECEIVE_INTERRUPT_FLAG)                        //Se a variável local "status" e status flag (EUSCI_A_UART_RECEIVE_INTERRUPT_FLAG) = 1
    {                                                                       //Se verdadeiro
        if(TXdata == 0xAA)
        {
            Cont = 1;
        }
        else
        {
            if (TXdata == 0x55)
            {
                MAP_UART_transmitData(EUSCI_A0_BASE, 0xff);
                Cont = 0;
            }
            else
            {
                if(TXdata == 0x5A)
                {
                    MAP_UART_transmitData(EUSCI_A0_BASE, 0xaa);
                    Cont = 0;
                }
                else
                {
                    if (Cont == 1)
                    {
                        matriz1 [1] = TXdata;
                        MAP_UART_transmitData(EUSCI_A0_BASE, TXdata);
                        Cont = 2;
                    }
                    else
                    {
                        if (Cont == 2)
                        {
                            matriz1 [2] = TXdata;
                            MAP_UART_transmitData(EUSCI_A0_BASE, TXdata);
                        }
                    }
                }
            }
        }
    }
}

//******************************************************************************
//
//This is the TIMERA interrupt vector service routine.
//
//******************************************************************************

void T32_INT1_IRQHandler(void)
{

    int out1 = pwm1[index_pwm1++];

    int out2 = pwm2[index_pwm2++];

    if(out1)
    {
        if(out2)
        {
            if(laststatusOUT1)
            {
                if(laststatusOUT2)
                {
                }
                else
                {
                    GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN4);
                    laststatusOUT2 = true;
                }
            }
            else
            {
                if(laststatusOUT2)
                {
                    GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN6);
                    laststatusOUT1 = true;
                }
                else
                {
                    GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN6 + GPIO_PIN4);
                    laststatusOUT1 = true;
                    laststatusOUT2 = true;
                }
            }
        }
        else
        {
            if(laststatusOUT1)
            {
                if(laststatusOUT2)
                {
                    GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN4);
                    laststatusOUT2 = false;
                }
                else
                {
                }
            }
            else
            {
                if(laststatusOUT2)
                {
                    GPIO_toggleOutputOnPin(GPIO_PORT_P2, GPIO_PIN6 + GPIO_PIN4);
                    laststatusOUT1 = true;
                    laststatusOUT2 = false;
                }
                else
                {
                    GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN6);
                    laststatusOUT1 = true;
                }

            }
        }
    }
    else
    {
        if(out2)
        {
            if(laststatusOUT1)
            {
                if(laststatusOUT2)
                {
                    GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN6);
                    laststatusOUT1 = false;
                }
                else
                {
                    GPIO_toggleOutputOnPin(GPIO_PORT_P2, GPIO_PIN6 + GPIO_PIN4);
                    laststatusOUT1 = false;
                    laststatusOUT2 = true;
                }
            }
            else
            {
                if(laststatusOUT2)
                {
                }
                else
                {
                    GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN4);
                    laststatusOUT2 = true;
                }
            }
        }
        else
        {
            if(laststatusOUT1)
            {
                if(laststatusOUT2)
                {
                    GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN6 + GPIO_PIN4);
                    laststatusOUT1 = false;
                    laststatusOUT2 = false;
                }
                else
                {
                    GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN6);
                    laststatusOUT1 = false;
                }
            }
            else
            {
                if(laststatusOUT2)
                {
                    GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN4);
                    laststatusOUT2 = false;
                }
                else
                {
                }
            }
        }
    }
    if(index_pwm1 >= 10)
    {
        index_pwm1 = 0;
    }
    else
    {
    }
    if(index_pwm2 >= 10)
    {
        index_pwm2 = 0;
    }
    else
    {
    }
    MAP_Timer32_clearInterruptFlag(TIMER32_BASE);
}

there is no mechanism to "sync" across multiple timers - the approach provided earlier aligns two timers sufficiently closely, but not synchronized.

the easiest way to perfect align two pwm signals is to generate them off the same timer, on different channels.

Hi Danny,

Yes you are right. This timing problem between two different Timers is solved with the code above. Now the problem is the PWM frequency.

I can not switch PWM outputs with higher frequencies with this code that I am using.

The Processor is already running at 48Mhz and I still can not, for example, generate an output with 100ns of period for example.

Anyway thanks a lot for your comments.

I think you aren't listening to bob landers' suggestion carefully. using timer32 interrupts to generate pwm will NOT get you anywhere to 10Mhz output, simply because of the overhead + ISR execution time.

what bob was saying is to use the timera's output compare feature. take a look at the datasheet and read his suggestions.

BTW, if you are really in need of 10Mhz pwm, rethink and triple-think of your approach and think of a dedicated pwm chip.