#define FSYS (20000000)
#define FREQ_VALUE_CALCULATION_TIME (25) ----------> Откъде идва тази стойност ? Правих си опити и ако я сложа по-голямо число, стойността на F излиза малко със закъснение на дисплея.

uint32 T; /* Съдържа периода на входния сигнал */

void interrupt Timer0_ISR(void) _At TIMER0
{
   static uint8 n = 0; /* Брояч на препълванията на таймера*/
   
   uint16 Tov; /* Съдържа времето за препълване на таймера */
   
   if(0 == (T0CTL0 & (1 << 0))) /* Прекъсване от препълване? */
   {/* Да */
      n++; /* Увеличаване на брояча на препълванията */
   }
   
   else
   {/* Не,прекъсване от прехващане */
      T = ((uint32)T0PWMH << 8 | T0PWML); /* Копиране на прехванатата стойност > T = T(t3) */
      
      Tov = ((uint16)T0RH << 8 | T0RL); /* Вземане на броячната стойност на таймера, която определя времето му за препълване, т.е. Tov */
      
      T += (uint32)n*Tov; /* Изчисляване на периода Т += n x Tov */
      
      n = 0; /* Нулиране на брояча на препълванията*/
   }
}

int main(void)
{
   uint16 F = 0; /* Честота */
   uint8 i = FREQ_VALUE_CALCULATION_TIME; /* Време за изчисляване на нова стойност на F */
   
   PortConfig();
   InterruptConfig();
   TimerConfig();
   
   while(1)
   {
      if(i != 0)
      {
         SendToDisplay(F);
         i--;
      }
      
      else
      {
         _di(); /* Забраняване на прекъсванията */
         F = FSYS / T; /* Изчисляване на честотата в Hz */
         _ei(); /* Разрешаване на прекъсванията */
         i = FREQ_VALUE_CALCULATION_TIME; /* Презареждане на времето за изчисляване на нова стойност на F */
      }
   }
}

uint32 T; /* Съдържа периода на входния сигнал */

void interrupt Timer0_ISR(void) _At TIMER0
{
   static uint8 n = 0; /* Брояч на препълванията на таймера */
   static uint8 j = 0; /* Брояч на прехващанията */
   
   uint16 Tov; /* Съдържа времето за препълване на таймера */
   
   if(0 == (T0CTL0 & (1 << 0))) /* Прекъсване от препълване ? */
   {/* Да */
      n++; /* Увеличаване на брояча на препълванията */
      
      if(1 == (T0CTL1 & (1 << 0))) /* Прекъсване от прехващане ? */
      {
         j = 0; /* Нулираме на брояча на прехващанията */
      }
   }
   
   else
   {/* Не,прекъсване от прехващане */
      T = ((uint32)T0PWMH << 8 | T0PWML); /* Копиране на прехванатата стойност > T = T(t3) */
      
      Tov = ((uint16)T0RH << 8 | T0RL); /* Вземане на броячната стойност на таймера, която определя времето му за препълване, т.е. Tov */
      
      T += (uint32)n*Tov; /* Изчисляване на периода Т += n x Tov */
      
      n = 0; /* Нулиране на брояча на препълванията */
   }   
}

volatile uint32 T; /* Съдържа периода на входния сигнал */
volatile uint8 overflow_count = 0; /* Брояч на препълванията на таймера */
volatile uint8 is_capture = 0; /* Флаг за прехващанията */

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

   if(0 == (T0CTL0 & (1 << 0))) /* Прекъсване от препълване ? */
   {
      overflow_count++;
   }
   else /* Прекъсване от прехващане! */
   {
      if(0 != is_capture)
      {
         T = (((uint16)T0PWMH << 8) | T0PWML);      
         Tov = (((uint16)T0RH << 8) | T0RL);      
         T += (uint32)overflow_count*Tov;
      }
      overflow_count = 0;
      is_capture = 1;
   }
}

volatile uint32 T;
uint32 atomic_var_T;
uintXX active IRQs;

active_IRQs = disableIRQ(TIMER0_IRQ);
atomic_var_T = T;
enable_IRQs(active_IRQs);

...
/* тука ползваме atomic_var_T колкото ни душа сака
и никога не ползваме директно Т. */

volatile uint32 T;
uint32 atomic_var_T;

do{
atomic_var_T = T;
} while(atomic_var_T != T);

...
/* ползваме atomic_var_T
и никога не ползваме директно Т. */

да речем в даден момент Т= 0х12345678
прочитам 1-ви байт от Т и го пращам към дисплей/сериен порт (пращаме 0х12)
прочитам 2-ри байт от Т и го пращам към дисплей/сериен порт (пращаме 0х34)
<<< тука се случва прехващане и влизаме в прекъсване>>>
стойността на Т е обновена в прекъсването и новата стойност е: Т = 0х87654321
<<< излизаме от прекъсване>>>
прочитам 3-ри байт от Т и го пращам към дисплей/сериен порт (пращаме 0х43)
прочитам 4-ти байт от Т и го пращам към дисплей/сериен порт (пращаме 0х21)

#define Tov (0xFFFF)

volatile uint32 T; /* Съдържа периода на входния сигнал */
volatile uint16 timer_MS = 0; /* старша част на таймера, разширен до 32 бита със софтуерен метод */
volatile uint8 is_capture = 0; /* Флаг за прехващанията */

void init_Timer0()
{
   ...
   T0RH = 0xFF;
   T0RL = 0xFF;
   ...
}

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

   if(0 == (T0CTL0 & (1 << 0))) /* Прекъсване от препълване ? */
   {
      timer_MS++;
   }
   else /* Прекъсване от прехващане! */
   {
      if(0 != is_capture)
      {
         T0_cnt = (((uint16)T0PWMH << 8) | T0PWML);
         Т = ((uint32)timer_MS<<16) | T0_cnt;
      }
      timer_MS = 0;
      is_capture = 1;
   }
}

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

   if(0 == (T0CTL0 & (1 << 0))) /* Прекъсване от препълване ? */
   {
      timer_MS++; ---> Ако разбирам правилно, тук увеличаваме старшата част на таймера, който вече е разширен до 32 бита ?
   }
   else /* Прекъсване от прехващане! */
   {
      if(0 != is_capture)
      {
         T0_cnt = (((uint16)T0PWMH << 8) | T0PWML); ---> Тук прехванатата стойност се записва в тези регистри (PWMH, PWML) и Т0_cnt ?
         Т = ((uint32)timer_MS<<16) | T0_cnt; ---> Тук изчисляваме периода, демек стойността на timer_MS се измества с 16 бита наляво, а за дясната част остава стойността на Т0_cnt и така се получава цял период ?
      }
      timer_MS = 0;
      is_capture = 1;
   }
}

#define FSYS (20000000)
#define FREQ_VALUE_CALCULATION_TIME (25) ---> Откъде идва тази стойност или аз си я избирам? Правих си опити и ако я сложа по-голямо число, стойността на F излиза малко със закъснение на дисплея?

int main(void)
{
   uint16 F = 0; /* Честота */
   uint8 i = FREQ_VALUE_CALCULATION_TIME; /* Време за изчисляване на нова стойност на F */
   
   PortConfig();
   InterruptConfig();
   TimerConfig();
   
   while(1)
   {
      if(i != 0)
      {
         SendToDisplay(F);
         i--;
      }
     
      else
      {
         _di(); /* Забраняване на прекъсванията */
         F = FSYS / T; /* Изчисляване на честотата в Hz */
         _ei(); /* Разрешаване на прекъсванията */
         i = FREQ_VALUE_CALCULATION_TIME; /* Презареждане на времето за изчисляване на нова стойност на F */
      }
   }
}

void interrupt Timer0_ISR(void) _At TIMER0
{   
...
    T0_cnt = (((uint16)T0PWMH << 8) | T0PWML); ---> Тук прехванатата стойност се записва в тези регистри (PWMH, PWML) и Т0_cnt ?
...
}

#define FREQ_VALUE_CALCULATION_TIME (25) ---> Откъде идва тази стойност или аз си я избирам? Правих си опити и ако я сложа по-голямо число, стойността на F излиза малко със закъснение на дисплея?

#define FSYS (20000000)
#define FREQ_VALUE_REFRESH_TIME (2500)

int main(void)
{
   uint32 atomic_var_T;
   uint16 F = 0; /* Честота */
   uint8 i = FREQ_VALUE_REFRESH_TIME / 4; /* Време за изчакване преди изчисляване на първата стойност на F */
   
   PortConfig();
   InterruptConfig();
   TimerConfig();
   
   while(1)
   {
      if(0 != i)
      {
         i--;
      }     
      else
      {
         _di();
         atomic_var_T = T;
         _ei();

         F = FSYS / atomic_var_T;

         SendToDisplay(F);

         i = FREQ_VALUE_REFRESH_TIME;
      }
   }
}

uint8 k; /* Коефициент на запълване */

void interrupt Timer0_ISR(void) _At TIMER0
{
   static uint8 overflow_count = 0; /* Брояч на препълванията на таймера*/
   
   static uint32 t_h = 0; /* Високо ниво на сигнала */
   static uint32 t_l = 0; /* Ниско ниво на сигнала */
   
   uint32 T; /* Период на сигнала */
   uint16 Tov; /* Съдържа времето за препълване на таймера */
   uint32 Tcap; /* Прехваната стойност */
   
   if(0 == (T0CTL0 & (1 << 0))) /* Прекъсване от препълване? */
   {/* Да */
      overflow_count ++; /* Увеличаване на брояча на препълванията */
   }
   
   else
   {/* Не,прекъсване от прехващане */
      Tcap = ((uint32)T0PWMH << 8 | T0PWML); /* Прочитаме записаната стойност в (PWMH,PWML) и я присвояваме на Tcap */
      Tov = ((uint16)T0RH << 8 | T0RL); /* Прочитаме записаната стойност в (RH, RL) и я присвояваме на Tov */
         
      if(0 == (T0CTL1 & (1 << 6))) /* Прекъсване от нарастващ фронт ? */
      {/* Да */
         t_l = Tcap + overflow_count * Tov; /* Изчисляване на ниското ниво на сигнала */
         T = t_h + t_l; /* Изчисляване на периода */
         k = (t_h * 100) / T; /* Изчисляване на коефициента на запълване */
         
         overflow_count = 0; /* Нулиране на брояча на препълванията*/
         
         T0CTL1 |= 1 << 6; /* Превключване към падащ фронт */
      }
      
      else
      {/* Прекъсване от падащ фронт */
         t_h = Tcap + overflow_count * Tov; /* Изчисляване на високото ниво на сигнала */
         
         overflow_count = 0; /* Нулиране на брояча на препълванията*/
         
         T0CTL1 &= ~(1 << 6); /* Превключване към нарастващ фронт */
      }
   }
}

int main(void)
{
   uint16 DutyCycle = 0; /* Честота */
   uint8 i = DUTY_VALUE_READING_TIME; /* Време за изчитане на нова стойност на DutyCycle */
   
   PortConfig();
   InterruptConfig();
   TimerConfig();
   
   while(1)
   {
      if(i != 0)
      {
         SendToDisplay(DutyCycle);
         i--;
      }
      
      else
      {
         _di(); /* Забраняване на прекъсванията */
         DutyCycle = k; /* Четене на измерения коефициент */
         _ei(); /* Разрешаване на прекъсванията */
         i = DUTY_VALUE_READING_TIME; /* Презареждане на времето за изчитане на нова стойност на DutyCycle */
      }
   }
}