Compiler/EK-TM4C123GXL: I WANT TO MAKE SQUARE WAVE THAT WAS ORIGINALLY HEART PULSE SENSOR'S ANALOG SIGNAL.

Hi,

  You are missing the image. Can you upload the image again?

   What is your blood pressure signal? Is it a digital signal or a analog signal? From your description, it doesn't seem like you care care to know the input voltage. If the signal is a digital input, why don't use just use GPIO mode? In GPIO mode, you can configure to detect an edge on the signal input. If the edge is detected, you can start the PWM. Another question is if you need the PWM to continuously running or just one pulse? If you just need one pulse rather than PWM continuously then you might just want to use another GPIO pin to simply toggle the pin whenever an edge is detected on your input. I'm not entirely clear on what you want to do and hence all the questions asked. 

ok It seems that my English was poor and I could not communicate properly.

What I just want is to represent the pulse signal, which is an analog signal, as a square wave using some method.

So one of the methods I've been looking for is this picture (high-band-operation.).

This may not be correct because it is just my thought

After this method used ADC to sample, I saw that the sampling value is 1,0 according to COMP.

So I thought that the values of 1,0 would be output as a square waveform.

If it is not correct, please comment. ;(

and If it is not, is there any way to make the output of the analog pulse sensor go into the kit's input so that the kit's output is in the form of a square wave?

and if you cannot see my picture, i suggest that you can see the picture where it is located 'TM4C123GXL's DATASHEET - 816p'

I'm sorry that I posted the wrong PIC.

the PIC is MID-BAND-OPERATION.

but what I want to say is 'HIGH-BAND-OPERATION.'

https://e2e.ti.com/support/microcontrollers/other/f/908/t/678508

The first answer's picture from the above address is what i wanted.

you know I don't know entirely how to put coding to get it out like that.

Is there any EXAMPLE CODE?..

please help me

yeah! I think maybe it will be correct soltuion.

I tried to discuss with my professor and friends hardly.

and tried so many googling.

Nothing comes out of sampling the input and converting the result to a digital value and then outputting it.

during 5 weeks I found out that I couldn't do it with my own ability to write the code myself.

Is there a homepage with examples or a website worth a reference?

I don't know how to implement the code.

Most of the code implementation descriptions were related to the color of the diode.

T.T  ....

I'm really sorry to keep asking.

Sadly, Nobody around me is good at handling 'CCS'

http://users.ece.utexas.edu/~valvano/arm/#Timer

There are many examples on this website, but it doesn't seem to have anything to do with what i'm tring to do.

Is there any other website that have CCS examples?

It's really hard to try CCS for the first time in this project.

please help me T.T

I am waiting for your reply every day and I feel very thankful.

Thanks to your help, I succeeded in sampling and outputting PWM.

But It did not happen when I tried to combine the two codes.

Below thing is my code

#include <stdbool.h>
#include <stdint.h>
#include "inc/hw_memmap.h"
#include "driverlib/adc.h"
#include "driverlib/debug.h"
#include "driverlib/gpio.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/uart.h"
#include "utils/uartstdio.h"

void
InitConsole(void)
{

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);

SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);

GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

UARTStdioConfig(0, 115200, 16000000);
}

#ifdef DEBUG
void
__error__(char *pcFilename, uint32_t ui32Line)
{
}
#endif
void
ConfigureUART(void)
{

MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);

UARTStdioConfig(0, 115200, 16000000);
}

int
main(void)
{
#if defined(TARGET_IS_TM4C129_RA0) || \
defined(TARGET_IS_TM4C129_RA1) || \
defined(TARGET_IS_TM4C129_RA2)
uint32_t ui32SysClock;
#endif

uint32_t pui32ADC0Value[1];

#if defined(TARGET_IS_TM4C129_RA0) || \
defined(TARGET_IS_TM4C129_RA1) || \
defined(TARGET_IS_TM4C129_RA2)
//
// Note: SYSCTL_CFG_VCO_240 is a new setting provided in TivaWare 2.2.x and
// later to better reflect the actual VCO speed due to SYSCTL#22.
//
ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_240), 20000000);
#else
SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
#endif

InitConsole();

UARTprintf("ADC ->\n");
UARTprintf(" Type: Single Ended\n");
UARTprintf(" Samples: One\n");
UARTprintf(" Update Rate: 250ms\n");
UARTprintf(" Input Pin: AIN0/PE3\n\n");

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, pui32ADC0Value);

UARTprintf("AIN0 = %d\n", pui32ADC0Value[0]);

#if defined(TARGET_IS_TM4C129_RA0) || \
defined(TARGET_IS_TM4C129_RA1) || \
defined(TARGET_IS_TM4C129_RA2)
SysCtlDelay(ui32SysClock / 12);
#else
SysCtlDelay(SysCtlClockGet() / 12);
#endif
MAP_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
MAP_SysCtlPWMClockSet(SYSCTL_PWMDIV_1);

MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);

MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);

MAP_GPIOPinConfigure(GPIO_PB6_M0PWM0);
MAP_GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_6);

MAP_PWMGenConfigure(PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_UP_DOWN |
PWM_GEN_MODE_NO_SYNC);

MAP_PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, (SysCtlClockGet() / 250));

MAP_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0,
MAP_PWMGenPeriodGet(PWM0_BASE, PWM_GEN_0) / 4); // I want to put pui32ADC0Value[0]/4000 where 4 is here

MAP_PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, true);

MAP_PWMGenEnable(PWM0_BASE, PWM_GEN_0);

}
}

The first problem I am curious about is that when there is only ADC in the while, it repeats normally, but if I put the pwm code together in 'while{1}', it works only once.

I thought it would be possible to express the ADC value in percent where the PWM's period is set

(MAP_PWMGenPeriodGet(PWM0_BASE, PWM_GEN_0) / 4); // I want to put pui32ADC0Value[0]/4000 where 4 is here) <<<

However, it was executed only once in the loop and ended, so there was no output.

How can I solve this problem?

Thanks to your help, I confirmed that the ADC keeps outputting.

but there is another problem which is  '

MAP_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0,
MAP_PWMGenPeriodGet(PWM0_BASE, PWM_GEN_0) *((pui32ADC0Value[0])/4095))

I thought that if I do that, the square wave will be output because the value that is 'pui32ADCValue[0]/4095' comes out in percent form.

BUT, the output waveform was a strange waveform.

The cause I thought is 

 ADC comes out very fast, the frequency of sqaure wave generation is 250HZ and the input signal's frequency is almost 1.5HZ BECAUSE it's my blood pulse.

So, to solve this problem, I tried to change the PWM's output frequency 

but I could not make 1.5hz 

like this MAP_PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, (SysCtlClockGet() / 1.5));

I do not think I'm sure the problem I've guessed.

What problem do I have to solve to make a square wave according to the changing input's ADC value

below code that I wrote

Thanks for continuing to answer. I've never seen like anyone as kind as you

#include <stdbool.h>
#include <stdint.h>
#include "inc/hw_memmap.h"
#include "driverlib/adc.h"
#include "driverlib/debug.h"
#include "driverlib/gpio.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/uart.h"
#include "utils/uartstdio.h"

void
InitConsole(void)
{

    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

    GPIOPinConfigure(GPIO_PA0_U0RX);
    GPIOPinConfigure(GPIO_PA1_U0TX);

    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

    UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);

    GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

    UARTStdioConfig(0, 115200, 16000000);
}

#ifdef DEBUG
void
__error__(char *pcFilename, uint32_t ui32Line)
{
}
#endif
void
ConfigureUART(void)
{

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

    MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
    MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
    MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

    UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);

    UARTStdioConfig(0, 115200, 16000000);
}

int
main(void)
{
    MAP_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
    SYSCTL_XTAL_16MHZ);
    MAP_SysCtlPWMClockSet(SYSCTL_PWMDIV_1);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);

    MAP_GPIOPinConfigure(GPIO_PB6_M0PWM0);
    MAP_GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_6);

    MAP_PWMGenConfigure(PWM0_BASE, PWM_GEN_0, PWM_GEN_MODE_UP_DOWN |
    PWM_GEN_MODE_NO_SYNC);


    MAP_PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, (SysCtlClockGet() / 250));

    MAP_PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, true);

    MAP_PWMGenEnable(PWM0_BASE, PWM_GEN_0);
#if defined(TARGET_IS_TM4C129_RA0) ||                                         \
        defined(TARGET_IS_TM4C129_RA1) ||                                         \
        defined(TARGET_IS_TM4C129_RA2)
    uint32_t ui32SysClock;
#endif

    uint32_t pui32ADC0Value[1];

#if defined(TARGET_IS_TM4C129_RA0) ||                                         \
        defined(TARGET_IS_TM4C129_RA1) ||                                         \
        defined(TARGET_IS_TM4C129_RA2)
    //
    // Note: SYSCTL_CFG_VCO_240 is a new setting provided in TivaWare 2.2.x and
    // later to better reflect the actual VCO speed due to SYSCTL#22.
    //
    ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
            SYSCTL_OSC_MAIN |
            SYSCTL_USE_PLL |
            SYSCTL_CFG_VCO_240), 20000000);
#else
    SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
                   SYSCTL_XTAL_16MHZ);
#endif

    InitConsole();

    UARTprintf("ADC ->\n");
    UARTprintf("  Type: Single Ended\n");
    UARTprintf("  Samples: One\n");
    UARTprintf("  Update Rate: 250ms\n");
    UARTprintf("  Input Pin: AIN0/PE3\n\n");

    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, pui32ADC0Value);

        UARTprintf("AIN0 = %d\n", pui32ADC0Value[0]);
        SysCtlDelay(1000000);

        MAP_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0,
        MAP_PWMGenPeriodGet(PWM0_BASE, PWM_GEN_0) *((pui32ADC0Value[0])/4095)); // pui32ADC0Value[0]/4095 means duty cycle


    }
}

Glad your problem is solved. If you don't mind, please share your code with the community so someone might benefit.