CCS/EK-TM4C123GXL: I don't Know why my output waveform is not correct

Hi,

  You wrote code like below and this will not work. It looks like your PWM period is 250Hz or slower. Just think about how long is one PWM period in 250Hz. It is 4mS. Now look at your code and see how fast to execute the MAP_PWMPulseWidthSet. It may just take in the range of uS or in hundreds of nS to execute the API. Before one duty cycle is complete, you are forcing a change for a different duty cycle.  In another word, the 4 MAP_PWMPulseWidthSet will execute before one duty cycle is complete. The first three MAP_PWMPulseWidthSet will neve take effect.

   I think you will get a much better luck to get what you want if you use the GPT timer in PWM mode where you can create a one-shot PWM. Another way you may try is to use the GPIO if I were you. You can simply set a pin low, wait for some time to expire and then set the pin high again. You can repeat this the number of times you want per your application. 

  The PWM module is used to generate a continuous PWM pulse train.  You should only update the duty cycle and make it synchronous so that the duty cycle update will take affect at the end of one duty cycle. 

  If this is your university homework or project, I will suggest you discuss with your professor/TA/classmates.

Hi,

  Which port are you trying to use for GPIO? If you are going to use PortC[3:0] then I will really suggest you NOT to. These are used for JTAG. If you repurpose them for GPIO then you will lose the capablity to debug your device which is not a good thing. There are many other GPIO ports you can use. Why don't you try other ports?

  Why don't reference the project0 example on how to use the GPIO. The blinky example is another one to reference. Below is the code for project0 which you can find in TivaWare library.

#include <stdint.h>
#include <stdbool.h>
#include "inc/hw_types.h"
#include "inc/hw_memmap.h"
#include "driverlib/sysctl.h"
#include "driverlib/gpio.h"

//*****************************************************************************
//
// Define pin to LED color mapping.
//
//*****************************************************************************

//*****************************************************************************
//
//! \addtogroup example_list
//! <h1>Project Zero (project0)</h1>
//!
//! This example demonstrates the use of TivaWare to setup the clocks and
//! toggle GPIO pins to make the LED's blink. This is a good place to start
//! understanding your launchpad and the tools that can be used to program it.
//
//*****************************************************************************

#define RED_LED   GPIO_PIN_1
#define BLUE_LED  GPIO_PIN_2
#define GREEN_LED GPIO_PIN_3

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

//*****************************************************************************
//
// Main 'C' Language entry point.  Toggle an LED using TivaWare.
//
//*****************************************************************************
int
main(void)
{
    //
    // Setup the system clock to run at 50 Mhz from PLL with crystal reference
    //
    SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
                    SYSCTL_OSC_MAIN);

    //
    // Enable and wait for the port to be ready for access
    //
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
    while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOF))
    {
    }
    
    //
    // Configure the GPIO port for the LED operation.
    //
    GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED);

    //
    // Loop Forever
    //
    while(1)
    {
        //
        // Turn on the LED
        //
        GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, RED_LED);

        //
        // Delay for a bit
        //
        SysCtlDelay(2000000);

        //
        // Turn on the LED
        //
        GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, BLUE_LED);

        //
        // Delay for a bit
        //
        SysCtlDelay(2000000);
    }
}

sungmin yoon said:

the first is to send a PWM output of 0101 when b is greater than 1000, i.e. send a PWM signal four times. But the input to the kit now is 1 Hz on the SINE waveform.
The output occurs once a second. If I can synchronize through GPIO, I would like to ask if this is possible.

What is your input? If this input is a GPIO input then you can configure it to generate an interrupt when an input edge is detected. In your ISR, you can generate your output corresponding to the input event. If your input is an ADC, you can also generate an interrupt when a conversion is complete. In your ADC ISR, you can generate your output. 

sungmin yoon said:

Second, I connected the output of the PB6 pin of the kit to the oscilloscope, and the output signal occurs once a second, but at some point, 0.999 output occurs three times in a row or two times in a row. What's wrong with this? Below is my Code (The if part of the code I posted above was modified.)

  I really don't think you are doing this right. Why are you using the PWM to generate 0101 when you can use the GPIO to create the 0101 much easily. Suppose you want to create 0101, this means each pulse duration will be 250mS. See below pseudo code. 

  if (b > 1000) {

      GPIOPinWrite(GPIO_PORTF_BASE, 0, 0); // Set the PF0 low. You can choose your own pin

      SysCtlDelay(xyz); // with xyz giving you 250mS. You can try SysCtlDelay(SysCtlClockSet() / 4 /3) to wait 250mS

      GPIOPinWrite(GPIO_PORTF_BASE, 0, 1); // Set the PF0 high. 

      SysCtlDelay(xyz); //  wait 250mS

      GPIOPinWrite(GPIO_PORTF_BASE, 0, 0); // Set the PF0 low. 

      SysCtlDelay(xyz); // wait 250mS

      GPIOPinWrite(GPIO_PORTF_BASE, 0, 1); // Set the PF0 high. 

      SysCtlDelay(xyz); //  wait 250mS

  } else {

  // your code for b < 1000

 }

sungmin yoon said:

Third, I don't know how to synchronize.
' MAP_PWMGenConfigure (PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_UP_DOWN |
PWM_GEN_MODE_GEN_SYNC_LOCAL);'
It wasn't SYNC_LOCAL but GEN_NO_SYNC. Didn't I change this to synchronize?
And you told me to use GPIO and PWM together is called GPIOPinTypePWM, how can I set up a duty cycle with this?

See above, you will have a much easier path to success if you use GPIO instead of PWM.  You don't want to use PWM to generate waveform like what you need. 

 Again, as much as I wanted to help, you should discuss with your professor/TA and classmates for your homework. 

With your help, I finally made it.

I regret why I didn't think about using gpio to create a square waveform.

but your code could not make the waveform that I want.

So, Here's my Code 0101 1010

  if (b>1100)
        {
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3,0x0); //off
            SysCtlDelay(500000);
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3); // on
            SysCtlDelay(500000);
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3,0x0); //off
            SysCtlDelay(500000);
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3); // on
            SysCtlDelay(500000);
        }
        else
        {
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3); // on
            SysCtlDelay(500000);
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0x0); //off
            SysCtlDelay(500000);
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3); // on
            SysCtlDelay(500000);
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0x0); //off
            SysCtlDelay(500000);
        }

I hope it helps someone who reads my post.