template<int INT_VECTOR>class Tuart_class {
public:
    #pragma vector=INT_VECTOR
    __interrupt static void UsartHandler()
    {

    }
    
};

Tuart_class<USARTC0_RXC_vect> usartc0;

class clUSART
    {
   public:    
        usart_t *c;
        
        void Init(usart_t *p){ c = p;};
        ...
        static void isr(usart_t *p);
   }
  
   clUSART u0, u1, u2;
  
    static void clUSART::isr(clUSART *p)
   {
        ...
   }
  
   __interrupt void u0_isr()
   {
        clUSART::isr(u0.c);
   }
   __interrupt void u1_isr()
    {
         clUSART::isr(u1.c);
    }
   __interrupt void u2_isr()
    {
         clUSART::isr(u2.c);
    }
   ...
   main()
   {
       u1.Init(p_usart1);
       u2.Init(p_usart2);
       u3.Init(p_usart3);
       ...
   }
   }

class clUSART
    {
   public:    
        usart_t *c;

   __interrupt void u0_isr()
   {
        clUSART::isr(u0.c);
   }
   __interrupt void u1_isr()
    {
         clUSART::isr(u1.c);
    }
   __interrupt void u2_isr()
    {
         clUSART::isr(u2.c);
    }
   ...
   }

template <USART_ENUM E>
class Tuart_class {
    typedef enum{
        usartC0 = 25,
        usartC1 = 28
    }USART_ENUM;
};

ISR(E){}    // USARTE0_RXC_vect
ISR(E+1){}    // USARTE0_DRE_vect
ISR(E+2){}    // USARTE0_TXC_vect

void main(){

     Tuart_class<Tuart_class::USART_ENUM::usartC0> usartc0;

}

  #pragma vector=USARTC0_RXC_vect
  __interrupt void u0_rxc_isr()
   {
        clUSART::isr(u0.c);
   }
  #pragma vector=USARTC1_RXC_vect
   __interrupt void u1__rxc_isr()
    {
         clUSART::isr(u1.c);
    }
   ..........

#define US0_BASE_ADDR //... Объявляем адреса устройств и векторов,
#define US1_BASE_ADDR //... вероятно, они уже где-то пределены
#define US0_VECTOR_BASE //...
#define US1_VECTOR_BASE //...

//структурка, которая описывает наши usart'ы

template<int US_BASE_ADDR>
struct us_descr {
static __no_init usart_t usart @ US_BASE_ADDR;

enum {
BASE_VECTOR_ADDR = US_BASE_ADDR == US0_BASE_ADDR? US0_VECTOR_BASE:
US_BASE_ADDR == US1_BASE_ADDR? US1_VECTOR_BASE:
//...
-1L,
RXC_VECTOR_ADDR = BASE_VECTOR_ADDR + RXC_VECTOR_OFFSET,
TXC_VECTOR_ADDR = BASE_VECTOR_ADDR + TXC_VECTOR_OFFSET,
DRE_VECTOR_ADDR = BASE_VECTOR_ADDR + DRE_VECTOR_OFFSET,
//...
};
};

/* базовый клас, в котором реализована вся низкоуровненвая работа,
типа конфигурирования, чтения/записи регистров и тп... */

class basic_usart {
protected:
usart_t &Us;
basic_usart(usart_t &us): Us(us) {}

public:
void do_something_with_us() { Us.REG_NAME = 10; }
//...
};

/* собственно наш класс, зависит от протокола и адреса порта,
с которыми мы хотим его связать. Реализует только обработчики
прерываний и интерфейс для создания экземпляра этого класса */

template <int US_BASE_ADDR, class PROTOCOL>
class usart: public basic_usart {
protected:
static PROTOCOL *protocol;

# pragma vector = us_descr<US_BASE_ADDR>::RXC_VECTOR_ADDR
static __interrupt void RXC_handler() {
protocol->OnRxChar( // в обработчиках делаем что надо с регистрами и
us_descr<US_BASE_ADDR>::usart.DATA_REG; // вызываем нужные методы протокола пусть он сам
); // разбирается с данными
}

# pragma vector = us_descr<US_BASE_ADDR>::TXC_VECTOR_ADDR
static __interrupt void TXC_handler() {
//...
}


# pragma vector = us_descr<US_BASE_ADDR>::DRE_VECTOR_ADDR
static __interrupt void DRE_handler() {
//...
}

//...
public:
usart(PROTOCOL *p): basic_usart(us_descr<US_BASE_ADDR>::usart) {
DRE_handler, RXC_handler, TXC_handler; // тут надо пнуть этих ребят иначе компилятор не создат
// их специализацию (IAR 4.12A)

protocol = p;
//...
}
};

template <int US_BASE_ADDR, class PROTOCOL>
PROTOCOL *usart<US_BASE_ADDR, PROTOCOL>::protocol = NULL;

template<int US_BASE_ADDR> usart_t us_descr<US_BASE_ADDR>::usart;

template <int US_BASE_ADDR>
class Protocol: public usart<US_BASE_ADDR, Protocol<US_BASE_ADDR> >
{
typedef usart<US_BASE_ADDR, Protocol<US_BASE_ADDR> > USART;

public:
void OnRxChar(int ch) {}
Protocol(): USART(this) {}
};