Port D ======
D0--RXD UART
D1--TXD UART
D2<--INT0 вход nIRQ, low
D3<--вход кнопки 1
D4-->выход Low (на VT)
D5<--вход кнопки 2
D6-->выход, приём/передача RF
------------------------------------------
Port B ======
B0-->nRES,low сброс RF12B
B1<-->(DCLK/CFIL)
B2-->выход(FSK)
B3<--вход(nINT)
-------
B4->nSEL
B5<-SDO
B6->DO(MO)
B7->SCK
///////////////////////////////////////////////////////////////////////////////
//работа на прерывании или стр.55 interrupt [USI_OVERFLOW]
// Universal Serial Interface initialization
// Mode: Three Wire (SPI)
// Clock source: Register & Counter=USICLK
// USI Counter Overflow Interrupt: Off
USICR=0x12;
==================================================
Прием информации от GPS-модуля. Прием информации происходит по прерыванию от модуля USART. 
Принятые байты заносятся в буфер до приема кода 0x0A. После этого проверяется заголовок, 
обязательные символы массива и допустимость принятых данных. При соответствии, 
принятые данные переписываются в текущие. Но, объём SRAM ВСЕГО 128байт, а пакет может достигать 255байт.
Поэтому, пока без прерываний и буфера. 

// USART initialization, прерывания по RX, TX
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud Rate: 57600
UCSRA=0x00;
UCSRB=0xD8;
UCSRC=0x06;
UBRRH=0x00;
UBRRL=0x0F; // 15 для 57600 и 14,745600 MHz
============
Без прерываний:
UCSRA=0x00;
UCSRB=0x18;
UCSRC=0x06;
UBRRH=0x00;
UBRRL=0x0F;
================================================
из Торнадо
UCSRA=0x02;//удвоение скорости обена
UCSRB=0x18;//разрешение приёма, передачи
UCSRC=0x86;//8data, 1stop, Asynchronous, выбор регистра UCSRC
UBRRH=0x00;
UBRRL=0x19;//Baud Rate: 38400 (Double Speed Mode)

=============================================
// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// Interrupt on any change on pins PCINT0-7: Off
// Interrupt on any change on pins PCINT8-10: Off
// Interrupt on any change on pins PCINT11-17: Off
MCUCR=0x00;
GIMSK=0x00;
с прерываниями:
MCUCR=0x00;
GIMSK=0x40; //вкл прерывания!!!
GIFR=0x40;  //вкл прерывания!!!

//================= GPS ===================================================//
Сообщения начинаются символом  «$» и заканчиваются символом «*», за которым 
последовательно идут две шестнадцатеричные цифры контрольной суммы «hh», 
символы возврата каретки <CR> и перевода строки <LF>. 
В качестве разделителя полей данных используется символ «,»
1.3 Контрольная сумма равна восьмибитному «исключающему ИЛИ» всех 
символов между символами «$» и «*» (не включая их). Передается в виде двух 
шестнадцатеричных цифр (символов) старшей тетрадой вперед.




//========== МУСОР ======================================================//


//#define WAIT_NIRQ_LOW() while(PIND&(1<<NIRQ))//пока нет флага окончания передачи
//#define WAIT_NIRQ_LOW() while(PIND.2==1)//пока нет флага окончания передачи
// PORTD.2=1  сдвиг влево 1 на NRIQ разрядов
/*
void test_prog(void)
{
unsigned char i=0;
unsigned char data=0;
//======= Тестовая программа ===========
           data= i++;//data= 53 это 5
           //printf("%d,%d\n", data);
        //printf("=========\n\r");
        //printf("123456789\n\r"); 
        //printf("test\n\r");
        //printf("=========\n\r");
         USART_Transmit(data);
         //USART_Receive(); //продолжит только после нажатия клавиши на клаве
         printf("test\n\r");
        //printf("=========\n\r");
        printf("Поехали\n\r");//кирилица работает только с кирил.шрифтами 
       //PORTD.6=1; //выкл
        LED_ON(); //выкл
       delay_ms(100);
                    
       //PORTD.6=0; //вкл VD                                         
       LED_OFF(); //вкл VD
       delay_ms(500);
       
       //========= end Тестовая программа =====
}


void InitUART( unsigned char baudrate )
{
 UBRRL=baudrate;
 UCSRB.RXEN=1;
 UCSRB.TXEN=1;
 UCSRB.RXCIE=0;
 //SetBit(UCSRB,RXEN); SetBit(UCSRB,TXEN);
 //UCSRB = BIT(RXEN) | BIT(TXEN);
}
// InitUART( 15 ); //  UBRRL=0x0F; 15 для 57600 и 14,745600 MHz
//InitUART( 103 );// скорость 9600б/сек для 16МГЦ

void USART_Init( unsigned int baudrate ) //Функция инициализации USART
{
    UBRRH = (unsigned char) (baudrate>>8);
    UBRRL = (unsigned char) baudrate;
    UCSRA = ( 1<<U2X); //Устанавливаем удвоение скорости
    UCSRB = (( 1<<RXEN)|(1<<TXEN)); //Разрешение на прием и на передачу через USART
    UCSRC = (1<<USBS)|(3<<UCSZ0);
}
unsigned char ReceiveByte( void )
            {
     while ( !(UCSRA & (1<<RXC)) );
     return UDR;
            }

void TransmitByte( unsigned char data )
            {
     while ( !(UCSRA & (1<<UDRE)) );
             UDR = data;
            }
*/
//=======================================================================//
//====== инициализация портов, SPI ===================
/*
void portInit() //инициализированы в init_ATtiny
{
  HI(CS);  // PORTB.4 SPI nSEL (chip select)
  HI(SDI); // PORTB.6 SPI DO uotput (RFM12B data input)
  LO(SCK); // PORTB.7 SPI clock
  DDRB = (1<<CS) | (1<<SDI) | (1<<SCK); //11010000(0xD0) <<4 <<6 <<7
  DDRD = (1<<LED);//PD6=Out Low 
}
*/
// External Interrupt 0 === программа обрабобтки прерывания ===
/*
interrupt [EXT_INT0] void ext_int0_isr(void) //сейчас выключено в init_ATtiny
{  
// Place your code here
   //void rfSend(unsigned char data)
  //{
    //while(WAIT_NIRQ_LOW); //wait for previously TX over
  //  writeCmd(0xB800 + data); //data - 8бит
  //}
 //PORTD.6=0; //вкл VD
 //delay_ms(500);
}
*/

//==================== USART работа с прерываниями =====
/*
#ifndef RXB8
#define RXB8 1
#endif

#ifndef TXB8
#define TXB8 0
#endif

#ifndef UPE
#define UPE 2
#endif

#ifndef DOR
#define DOR 3
#endif

#ifndef FE
#define FE 4
#endif

#ifndef UDRE
#define UDRE 5
#endif

#ifndef RXC
#define RXC 7
#endif

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define data_OVERRUN (1<<DOR)
#define data_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)


  // USART Receiver buffer   ===========================
#define RX_BUFFER_SIZE 8
char rx_buffer[RX_BUFFER_SIZE];

#if RX_BUFFER_SIZE <= 256
unsigned char rx_wr_index,rx_rd_index,rx_counter;
#else
unsigned int rx_wr_index,rx_rd_index,rx_counter;
#endif

// This flag is set on USART Receiver buffer overflow
bit rx_buffer_overflow;

// USART Receiver interrupt service routine
interrupt [USART_RXC] void usart_rx_isr(void)
{
char status,data;
status=UCSRA;
data=UDR;
if ((status & (FRAMING_ERROR | PARITY_ERROR | data_OVERRUN))==0)
   {
   rx_buffer[rx_wr_index++]=data;
#if RX_BUFFER_SIZE == 256
   // special case for receiver buffer size=256
   if (++rx_counter == 0) rx_buffer_overflow=1;
#else
   if (rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0;
   if (++rx_counter == RX_BUFFER_SIZE)
      {
      rx_counter=0;
      rx_buffer_overflow=1;
      }
#endif
   }
}

#ifndef _DEBUG_TERMINAL_IO_
// Get a character from the USART Receiver buffer
#define _ALTERNATE_GETCHAR_
#pragma used+
char getchar(void)
{
char data;
while (rx_counter==0);
data=rx_buffer[rx_rd_index++];
#if RX_BUFFER_SIZE != 256
if (rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0;
#endif
#asm("cli")
--rx_counter;
#asm("sei")
return data;
}
#pragma used-
#endif

// USART Transmitter buffer  =======================
#define TX_BUFFER_SIZE 8
char tx_buffer[TX_BUFFER_SIZE];

#if TX_BUFFER_SIZE <= 256
unsigned char tx_wr_index,tx_rd_index,tx_counter;
#else
unsigned int tx_wr_index,tx_rd_index,tx_counter;
#endif

// USART Transmitter interrupt service routine
interrupt [USART_TXC] void usart_tx_isr(void)
{
if (tx_counter)
   {
   --tx_counter;
   UDR=tx_buffer[tx_rd_index++];
#if TX_BUFFER_SIZE != 256
   if (tx_rd_index == TX_BUFFER_SIZE) tx_rd_index=0;
#endif
   }
}

#ifndef _DEBUG_TERMINAL_IO_
// Write a character to the USART Transmitter buffer
#define _ALTERNATE_PUTCHAR_
#pragma used+
void putchar(char c)
{
while (tx_counter == TX_BUFFER_SIZE);
#asm("cli")
if (tx_counter || ((UCSRA & data_REGISTER_EMPTY)==0))
   {
   tx_buffer[tx_wr_index++]=c;
#if TX_BUFFER_SIZE != 256
   if (tx_wr_index == TX_BUFFER_SIZE) tx_wr_index=0;
#endif
   ++tx_counter;
   }
else
   UDR=c;
#asm("sei")
}
#pragma used-
#endif
//============================ USART end =============
*/

//====16bit функция передачи по USI, 490кГц, 2,04мкс, 30такт ===
/*
unsigned int writeCmd(unsigned int cmd) //16bit, 490кГц, 2,04мкс, 30такт
{
  unsigned char i;
  unsigned int recv_16;
  recv_16 = 0;
  LO(SCK); // PORTB.7 SPI clock 
  LO(CS);  // PORTB.4 SPI nSEL (chip select ENABLE)
  for(i=0; i<16; i++) 
  {
    if(cmd&0x8000) 
    HI(SDI);      //PORTB.6=1 SPI DO uotput (RFM12B data input)
    else LO(SDI); 
    HI(SCK);      //PORTB.7=1 SPI clock
    recv_16<<=1;     //сдвиг влево на 1бит
    if( PINB&(1<<SDO) ) // PORTB.5 SPI DI input (RFM12B data output)
   {
      recv_16|=0x0001;  //побитовая операция ИЛИ recv_16 и 0х0001
    }
    LO(SCK); // PORTB.7 SPI clock
    cmd<<=1; //сдвиг влево на 1бит
  }
  HI(CS); //PORTB.4 SPI nSEL (chip select DISALBE)
  return recv_16;
}

  
void rfSend(unsigned char data) //передача 0xB800 + data - 8бит
  {
    while(WAIT_NIRQ_LOW); //wait for previously TX over PIND.2=0
    writeCmd(0xB800 + data); //data - 8бит
    //writeCmd(data); //data - 8бит
  }
*/

//====16bit функция передачи по USI 1,05МГц, 14тактов,0,95мкс===
/*
//unsigned char SPI_WR_M (unsigned char data_w) //8bit функция передачи/приёма байта по USI
unsigned int writeCmd(unsigned int cmd) 
{
  unsigned int recv_16b=0; //16bit полученные из USIDR
    LO(CS);  // PORTB.4 SPI nSEL (chip select ENABLE)
    USIDR = cmd>>8;//8bit отправляем сарший байт в сдвиговый регистр
	USISR |= (1<<USIOIF);//сбрасываем флаг
	while(!(USISR & (1<<USIOIF)))//пока нет флага окончания передачи
	{  //формируем тактирующие импульсы
	   USICR |= (1<<USIWM0) | (1<<USICS1) | (1<<USICLK) | (1<<USITC);
	}
	recv_16b = USIDR<<8; //сохраняем старший байт из USIDR
    USIDR = cmd&0x00FF;//оставляем младший 8бит разряд (вместо FF)
    USISR |= (1<<USIOIF);//сбрасываем флаг
	while(!(USISR & (1<<USIOIF)))//пока нет флага окончания передачи
    {  //формируем тактирующие импульсы
	   USICR |= (1<<USIWM0) | (1<<USICS1) | (1<<USICLK) | (1<<USITC);
	}
    recv_16b |=USIDR; //(побитовая операция ИЛИ) добовляем младший байт из USIDR
    HI(CS); //PORTB.4 SPI nSEL (chip select DISALBE)
    return recv_16b; //возврашаем 16bit полученные из USIDR
}
*/
/* 
 //cmd_8b заменено на rf_byte
void rfSend_Byte(unsigned char rf_byte) //8bit функция передачи по USI 1,05МГц, 14тактов,0,95мкс
{
 while(WAIT_NIRQ_LOW); //wait for previously TX over PIND.2=0
 USIDR = rf_byte;//8bit отправляем байт в сдвиговый регистр
 USISR |= (1<<USIOIF);//сбрасываем флаг
	while(!(USISR & (1<<USIOIF)))//пока нет флага окончания передачи
	{  //формируем тактирующие импульсы
	   USICR |= (1<<USIWM0) | (1<<USICS1) | (1<<USICLK) | (1<<USITC);
	} 
}  
*/
 /* 
 void rfSend(unsigned char data)
 {
  while(WAIT_NIRQ_LOW); //wait for previously TX over PIND.2=0
  USIDR = data;//8bit передаваемые данные в сдвиговый регистр
  USISR |= (1<<USIOIF);//сбрасываем флаг
	while(!(USISR & (1<<USIOIF)))//пока нет флага окончания передачи
	{  //формируем тактирующие импульсы
	   USICR |= (1<<USIWM0) | (1<<USICS1) | (1<<USICLK) | (1<<USITC);
	}
  
  return (USIDR);//возвращаем полученные данные
  while( (RFM12B_NIRQ_PIN&(1<<RFM12B_NIRQ_BIT)) ){};
}
 */