{
         t_l = Tcap + overflow_count * Tov;
         T = t_h + t_l;
         k = (t_h * 100) / T;
         
         overflow_count = 0;
         
         T0CTL1 |= 1 << 6; /* Превключване към падащ фронт */
      }

...
         T = t_h + t_l;
         k = (t_h * 100) / T;
...

#define Tov                  ((uint16)20000) /* тука знаеш какво да сложиш 20000 е само предположение */
#define T0CAP_LOW      (0)
#define T0CAP_HIGH     (1)
#define FIFO_SIZE        (16)

#define DUTY_VALUE_READING_TIME (25)

volatile uint8 overflow_count = 0;
volatile uint32 t_interval[2][FIFO_SIZE];
volatile uint8 head_i;


void interrupt Timer0_ISR(void) _At TIMER0
{
    uint16 Tcap;

    if(0 == (T0CTL0 & (1 << 0)))
    {
        overflow_count ++;
    }
    else
    {
        Tcap = ((uint32)T0PWMH << 8 | T0PWML);

        if(0 == (T0CTL1 & (1 << 6)))
        {
            T0CTL1 |= 1 << 6;
            t_interval[T0CAP_LOW][head_i % FIFO_SIZE] = Tcap + overflow_count * Tov;
            head_i++;
        }

        else
        {
            T0CTL1 &= ~(1 << 6);
            t_interval[T0CAP_HIGH][head_i % FIFO_SIZE] = Tcap + overflow_count * Tov;
        }

        overflow_count = 0;
    }
}

int main(void)
{
    uint8 i = DUTY_VALUE_READING_TIME;
    uint8 tail_i;
    uint16 DutyCycle = 0;
    uint32 T = 0;
    uint32 t_h;
    uint32 t_l;

    head_i = 0;
    tail_i = 0;

    PortConfig();
    InterruptConfig();
    TimerConfig();

    while(1)
    {
        if(i != 0)
        {
            SendToDisplay(DutyCycle);
            i--;
        }
        else
        {
            if(head_i != tail_i)
            {
                t_h = t_interval[T0CAP_HIGH][tail_i % FIFO_SIZE];
                t_l = t_interval[T0CAP_LOW][tail_i % FIFO_SIZE];
                T  = t_h + t_l;
                if(0 != T)
                {
                    DutyCycle = (t_h * 100) / T;
                }

                tail_i++;
            }

            i = DUTY_VALUE_READING_TIME;
        }
    }
}

volatile uint8 overflow_count = 0; /* Брояч на препълванията на таймера*/
volatile uint32 t_interval[2][FIFO_SIZE]; /* Двумерен масив - т.е. 2 едномерни масива с по 16 елемента */
volatile uint8 head_i; /* Индекс на масива, който вкарва нови данни */

void interrupt Timer0_ISR(void) _At TIMER0
{
   uint16 Tcap; /* Прехваната стойност */

    if(0 == (T0CTL0 & (1 << 0))) /* Прекъсване от препълване? */
    {/* Да */
        overflow_count ++; /* Увеличаване на брояча на препълванията */
    }
   
    else
    {/* Не,прекъсване от прехващане */
        Tcap = ((uint32)T0PWMH << 8 | T0PWML); /* Прочитаме записаната стойност в (PWMH,PWML) и я присвояваме на Tcap */

        if(0 == (T0CTL1 & (1 << 6))) /* Прекъсване от нарастващ фронт ? */
        {/* Да */
            T0CTL1 |= 1 << 6; /* Превключване към падащ фронт */
         
            t_interval[T0CAP_LOW][head_i % FIFO_SIZE] = Tcap + overflow_count * Tov; /* Изчислената стойност на ниското
         ниво се записва в 0-ят елемент на едномерният масив (T0CAP_LOW) - 0 % 16 = 0 - Ако левият операнд е по-малък от десния, резултатът е равен на стойността на левия операнд. */
         
            head_i++; /* Увеличаваме индекса на масива, който вкарва данните за да може следващата стойност да се зареди в поредният елемент */
        }

        else
        {/* Не, прекъсване от падащ фронт ? */
            T0CTL1 &= ~(1 << 6); /* Превключване към нарастващ фронт */
         
            t_interval[T0CAP_HIGH][head_i % FIFO_SIZE] = Tcap + overflow_count * Tov; /* Изчислената стойност на високото
         ниво се записва в 0-ят елемент на едномерният масив (T0CAP_HIGH) - 0 % 16 = 0 - Ако левият операнд е по-малък от десния, резултатът е равен на стойността на левия операнд.*/
        }
      
      overflow_count = 0; /* Нулиране на брояча на препълванията*/
    }
}

int main(void)
{
   uint16 DutyCycle = 0; /* Коефициент на запълване */
   uint8 i = DUTY_VALUE_READING_TIME; /* Време за изчитане на нова стойност на DutyCycle */
   uint32 t_h; /* Високо ниво на сигнала */
        uint32 t_l; /* Ниско ниво на сигнала */
   uint8 tail_i; /* Индекс на масива, който изважда данните */
   uint32 T = 0; /* Период на сигнала */
   
   head_i = 0; /* Нулираме индекса, който вкарва нови данни */
        tail_i = 0; /* Нулираме индекса, който изважда данните */
   
   PortConfig();
   InterruptConfig();
   TimerConfig();
   
   while(1)
   {
      if(i != 0)
      {
         SendToDisplay(DutyCycle);
         i--;
      }
      
      else
      {
         if(head_i != tail_i) /* Ако стойността на вкараните данни е различна от стойността на извадените */
                        {
                             t_h = t_interval[T0CAP_HIGH][tail_i % FIFO_SIZE]; /* Стойността, която е в 0-ят елемент на едномерният
            масив (T0CAP_LOW) се присвоява на t_h */
                             t_l = t_interval[T0CAP_LOW][tail_i % FIFO_SIZE]; /* Стойността, която е в 0-ят елемент на едномерният
            масив (T0CAP_LOW) се присвоява на t_h */
                             T  = t_h + t_l; /* Изчисляване на периода */

                             if(0 != T) /* Ако 0 е различно от стойността на периода */
                             {
                                 DutyCycle = (t_h * 100) / T; /* Изчисляване на коефициента на запълване */
                             }

                             tail_i++; /* Увеличаваме индекса на масива, който изважда данните за да може да дойде ред на следващият елемент (стойност) */
                        }

                        i = DUTY_VALUE_READING_TIME; /* Презареждане на времето за изчитане на нова стойност на DutyCycle */
      }
   }
}