Breathing led in Tiva C series TM4C123G

If you are doing it with your delay function and your delay resolution is in seconds as suggested in the code of course it will "blink" - the frequency needs to be faster than human visual perception - say for example about 50Hz, then to get a smooth variation you might divide that up into say 20 levels, requiring a millisecond delay.

In any case your delay() function defeats itself by taking a floating point number of seconds but comparing it with an integer loop counter - it will only ever work in whole seconds.

So given a function delayms( unsigned millisec ) (which I discuss later) then:

#define BREATHE_UPDATE_MS 100
#define BREATHE_MINIMUM 0
#define PWM_PERIOD_MS 20

unsigned tick = 0 ;
unsigned duty_cycle = 0 ;
unsigned cycle_start_tick= 0 ;

unsigned breath_update_tick = 0 ;
int breathe_dir = 1 ;

for(;;)
{
    // If in PWM "mark"...
    if( tick - cycle_start_tick < duty_cycle )
    {
        // LED on
        GPIO_PORTF_DATA_R |= 0x02 ;
    }
    // else PWM "space"
    else
    {
        // LED off
        GPIO_PORTF_DATA_R &= ~0x02 ;
    }

    // Update tick counter
    tick++ ;

    // If PWM cycle complete, restart
    if( tick - cycle_start_tick >= PWM_PERIOD_MS )
    {
        cycle_start_tick = tick ;
    }

    // If time to update duty-cycle...
    if( tick - breath_update_tick > BREATHE_UPDATE_MS )
    {
        breath_update_tick = tick ;
        duty_cycle += breathe_dir ;
        if( duty_cycle >= PWM_PERIOD_MS )
        {
            // Breathe in
            breathe_dir = -1 ;
        }
        else if( duty_cycle == BREATHE_MINIMUM )   
        {
            // Breathe out
            breathe_dir = 1 ;
        }
    }
 
    delayms( 1 ) ;
}

Change BREATHE_UPDATE_MS to breathe faster, change BREATHE_MINIMUM to "shallow breathe" - i.e. not dim to off.

If your delay function truly results in a delay resolution in seconds then approximately and rather crudely:

void delayms( unsigned millisec )
{
   for( int c = 0; c < millisec; c++ )
   {
       for( volatile int d = 0; d < 4000; d++ ) {}
   }
}

However that suggests to me a rather low core clock rate, so you may need to adjust that. Note the use of volatile to prevent the removal of the empty loop by the optimiser. The problem with this delay is that you will need to calibrate it to the clock speed of your target and its timing is likely to differ in any case depending on what compiler you use and what compiler options you use. It is generally a poor solution.

In practice using a "busy-loop" delay for this is ill-advised and crude and it would be better to use the Cortex-M SYSTICK:

volatile uint32_t tick = 0 ;
  
void SysTick_Handler(void)  
{
    tick++ ;
}

... removing the tick and tick++ from the original; code. Then you don't need a delay in the loop above because all the timing is pegged to the value of tick. However should you want a delay for other reasons then:

delayms( uint32_t millisec )
{
    uint32_t start = tick ;
    while( tick - start < millisec ) ;
}

Then you would initialise the SYSTICK at start-up thus:

int main (void)  
{
    SysTick_Config(SystemCoreClock / 1000) ;
 
    ...
}

This assumes that you are using the CMSIS, but your code suggests that you are not doing that (or even using a vendor supplied register header). You will in that case need to get down and dirty with the SYSTICK and NVIC registers if you (or your tutor) insists on that. The source for SysTick_Config() is as follows:

__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
{
  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
  {
    return (1UL);                                                   /* Reload value impossible */
  }

  SysTick->LOAD  = (uint32_t)(ticks - 1UL);                         /* set reload register */
  NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
  SysTick->VAL   = 0UL;                                             /* Load the SysTick Counter Value */
  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
                   SysTick_CTRL_TICKINT_Msk   |
                   SysTick_CTRL_ENABLE_Msk;                         /* Enable SysTick IRQ and SysTick Timer */
  return (0UL);                                                     /* Function successful */
}