#include "com0.h"

class cHuProt:public cUsart0 {
  protected:  
              void    HU_Rx_Byte(void);
  public:
              ui8     Recive_Pack_HU(void);
              ui8     Recive_Pack_HU_End(void);
              ui8     Init_HU(void);
              ui8     Reset_Recive_HU(void);
              ui8     Expect_new_HU(void);
              ui8     ECM_HU_len(void);
              ui8*    Get_Point_to_ECM_HU_data(void);
              ui8*    Get_Point_to_HU_S(void);
              ui8*    Get_Point_to_HU_C(void);
              ui8*    Get_Point_to_HU_I(void);
              ui8     DW_HU_Transmit(ui8 *pData);
              
  //cHumaxProt();
  //~cHumaxProt();
};

class cUsart0 {
  protected:
              ui8 Usart0_Tx_Raw(ui8 tx_char);
              ui8 Usart0_RX_Raw(void);
  public:
              ui8 Usart0_Init(ui16 ubrr);
              ui8 Usart0_Tx_Data(ui8 *pData, ui8 len_data);
              ui8 Usart0_Tx_Char(ui8 tx_char);
              
  //Usart0();
  //~Usart0();
};

/////////////////////////////////////////////////////////////////////////////
// Реализация класса cUsart0
/////////////////////////////////////////////////////////////////////////////
....
....
....

#pragma vector = USART0_RXC_vect
__interrupt void cHuProt::HU_Rx_Byte(void) {
      temp=ui8 Usart0_RX_Raw();
      ......
      ......
}

#pragma vector = USART0_RXC_vect
__interrupt void Recive_Byte_from_tu(void) {
   ui8 Rx_Ch = Tu.HU_Rx_Byte();
....
....
....}

  uart.rxbuf[uart.rxpos++] = U0RXBUF;
  uart.rxpos &= uart.rxsize;

#define MODULES_IN_TIMER_A      2
#define MODULES_IN_TIMER_B      6
#define TIMER_A                'A'
#define TIMER_B                'B'
template <char Timer> class TTimers
{
  protected:
    static const BYTE nModules = (Timer == TIMER_A) ? (MODULES_IN_TIMER_A) : (MODULES_IN_TIMER_B);
    // Флаги состояния модулей захвата/сравнения.
    static volatile bool run[nModules];
    // Старший байт счетчика времени работы таймера.
    static volatile WORD hi_Word_of_Tick_Cntr;
  public:
    // Конструктор класса.
    inline TTimers()
      {
        // Обнулим счетчик времени работы таймера.
        hi_Word_of_Tick_Cntr = 0;
        // Выключим все модули захвата/сравнения.
        for(register IDX i = 0; i < nModules; i++) { Dis(i); Reset(i); }
        // Программируем таймер:
        // синхронизация от ACLK, счетчик 16 бит, режим непрерывного счета,
        // прерывание по переполнению запрещено, все таймеры независимы.
        (Timer == TIMER_A) ? (TACTL = TASSEL0 + MC1 + TACLR) : (TBCTL = TBSSEL0 + MC1 + TBCLR);
      }

    // Методы управления прерываниями от модулей захвата/сравнения.
    static inline void Ena(IDX i) { *(&((Timer == TIMER_A) ? (TACCTL1) : (TBCCTL1)) + i) = CCIE; }
    static inline void Dis(IDX i) { *(&((Timer == TIMER_A) ? (TACCTL1) : (TBCCTL1)) + i) = 0x00; }

    // Методы загрузки значения в регистр сравнения.
    static inline WORD Remained(IDX i)          { return *(&((Timer == TIMER_A) ? (TACCR1) : (TBCCR1)) + i) - ((Timer == TIMER_A) ? (TAR) : (TBR)); }
    static inline void Load(IDX i, WORD val)    { *(&((Timer == TIMER_A) ? (TACCR1) : (TBCCR1)) + i) = ((Timer == TIMER_A) ? (TAR) : (TBR)) + val;  }

    // Методы проверки/сброса/установки флага срабатывания таймера.
    static inline bool is_Setting(IDX i)       { return run[i] == true; }
    static inline void Reset(IDX i)            { run[i] = false;        }
    static inline void Set(IDX i)              { run[i] = true;         }

    // Обработчик прерывания.
    #pragma vector = (Timer == TIMER_A) ? (TIMERA1_VECTOR) : (TIMERB1_VECTOR)
    static __interrupt void Timer_IRQ(void)
      {
        IDX i = (Timer == TIMER_A) ? (TAIV) : (TBIV);
        if(i == ((Timer == TIMER_A) ? (0x0a) : (0x0e)))
          {
            // Прерывание по переполнению.
            // Инкрементируем старший байт счетчика работы таймера.
            hi_Word_of_Tick_Cntr++;
          }
        else
          {
            // Прерывание от модулей захвата/сравнения.
            i = (i >> 2) - 1;
            Dis(i);                           // Запрещаем прерывания от модуля захвата/сравнения.
            Set(i);                           // Выставляем признак завершения счета.
            __low_power_mode_off_on_exit();   // Выходим из режима пониженного потребления.
          }
      }
};

#pragma vector = (Timer == TIMER_A) ? (TIMERA1_VECTOR) : (TIMERB1_VECTOR)

struct TIMER_A {
enum Consts {
   nModules = 2,
   TxCTLImg = TASSEL0 + MC1 + TACLR,
   ...
};
BYTE& TxCTL() {return TACTL;}
...
};

// Для TIMER_B аналогично

template <class Timer> class TTimers : private Timer
{
  protected:
    static volatile bool run[nModules];
    // Старший байт счетчика времени работы таймера.
    static volatile WORD hi_Word_of_Tick_Cntr;
  public:
    // Конструктор класса.
    inline TTimers()
      {
        // Обнулим счетчик времени работы таймера.
        hi_Word_of_Tick_Cntr = 0;
        // Выключим все модули захвата/сравнения.
        for(register IDX i = 0; i < nModules; i++) { Dis(i); Reset(i); }
        // Программируем таймер:
        // синхронизация от ACLK, счетчик 16 бит, режим непрерывного счета,
        // прерывание по переполнению запрещено, все таймеры независимы.
        TxCTL() = TxCTLImg;
      }
...
};