The Receiver project:

/*********************************************
Datum    : 03.07.2005
Author : H. Brachschoss
AVR          : ATmega32
Receiver
*********************************************/

#include <mega32.h>                           
#include <delay.h>
#include <math.h>
#include <sleep.h>
#include <stdio.h>
#include <string.h>
#include <sleep.h>

// Alphanumeric LCD Module functions
#asm
   .equ __lcd_port=0x15
#endasm
#include <lcd.h>                
                                  
                              
#define xtal 16000000L                              
                              
// Declare your global variables here                                 
          
#define  A0  55                                   
#define  A1      110
#define  A2      220  // in Hz
#define  B2      233
#define  H2      247
#define  C2      262
#define  CIS2    277
#define  D2      294
#define  DIS2    311
#define  E2      330
#define  F2      349
#define  FIS2    370
#define  G2      392
#define  GIS2    415

#define  A3      440
#define  B3      466
#define  H3      494
#define  C3      523
#define  CIS3    554
#define  D3      587
#define  DIS3    622
#define  E3      659
#define  F3      698
#define  FIS3    740
#define  G3      784
#define  GIS3    830   

#define  T12000 // Tonlänge (ms)
#define  T21000
#define  T4 500
#define  T8 250
#define  T16 125

#define  T10   0// keine Pause   (ms)
#define  T11   5
#define  T12 10
#define  T13 20
#define  T14 30
#define  T15 40
#define  P1      50                

#define TERMINAL 0x01// Masterterminal
#define STX0x02
#define ETX0x03
#define SYN0x16
#define DC10x11// Decive Control 1 für Bewegungsmelder
#define DC20x12// Device Control 2
#define DC30x13                            // Device Control 3


char adc0[10] ;   
unsigned int d_adc0=0 ;// Beleuchtung 
unsigned int d_adc1=0 ;// Feldstärke
unsigned int d_adc2=0 ;                        // Batterie
unsigned int light=0 ;      
char strText[15] [17] ;
unsigned int sleepcnt=0 ; 
char strRecBuff[17] ;   
unsigned int isrflag=0 ;    
typedef unsigned char byte ;    
unsigned int lighton=0 ;
unsigned int terminalkennung=0 ;                    
unsigned char srbcklight=1 ;
unsigned char srsoundon=1 ;
unsigned int wdtcnt=0 ;           
unsigned int displayoff=0 ;
unsigned int rcvint=0 ;


eeprom unsigned char eebcklight=1 ;// NOV Speicher für Hintergrundbeleuchtung
eeprom unsigned char eesoundon=1 ;// NOV Speicher für sound



// Character table für selbstdefinierte Zeichen
flash byte char0[8]={
0b00000000,
0b00000001,
0b00000001,
0b00000001,
0b00000111,
0b00001001,
0b00000110,
0b00000000
};

flash byte char1[8]={
0b00000000,
0b00000110,
0b00001001,
0b00001110,
0b00001000,
0b00001000,
0b00001000,
0b00000000
};
                      
flash byte char2[8]={
0b00000000,
0b00000000,
0b00001110,
0b00010001,
0b00010001,
0b00001110,
0b00000000,
0b00000000
};
              
              

// function für die selbsdefinierten Zeichen
void define_char(byte flash *pc, byte char_code)
{
byte i,a ;
a=(char_code)<<3 | 0x40 ;
for (i=0; i<8; i++)
lcd_write_byte(a++, *pc++) ;

}                                   


#define ADC_VREF_TYPE 0xC0
// Read the AD conversion result
unsigned int read_adc(unsigned char adc_input)
{
ADMUX=adc_input|ADC_VREF_TYPE;
// Start the AD conversion
ADCSRA|=0x40;
// Wait for the AD conversion to complete
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
return ADCW;
}
            


void check_batterie(void)
{
       d_adc2=read_adc(2) ;                  
}


void check_fieldstrength(void)
{
       d_adc1=read_adc(1) ;                  
}

void check_light(void)
{             

d_adc0=read_adc(0) ;
if (d_adc0<=20) 
if (lighton!=1)
{         
while (light<128)                  // LCD Beleuchtung ein
{     
light++ ;
delay_ms(5) ;
OCR1A=light ;   
}     
lighton=1 ;
       };
      
if (d_adc0>20)                                     // LCD Beleuchtung aus
{
OCR1A=0 ;
lighton=0 ;
light=0 ;
}                                 




}                           
                      


void pause(unsigned int timeout)
{
long n ;                    
double schleifen ;
unsigned int ischleifen ;

schleifen = 1000 * timeout ;
ischleifen = schleifen ;

for (n=0; n<schleifen;n++)
delay_us(1) ;
}

void note(double freq, double dauer, unsigned int timeout)
{
long n,i ;    
double frequenz ;           
double schleifen ;
unsigned int ifrequenz, ischleifen ;

freq = freq * 10 ;
frequenz = 1 / freq ;
frequenz = frequenz / 2 ;
frequenz = frequenz * 1000000 ;
schleifen = 1/ (frequenz * 2 ) ;    
schleifen = schleifen * 1000 ;
schleifen = (schleifen * dauer) / 10 ;
ifrequenz = frequenz ;          
ischleifen = schleifen ;

for(n=0;n<ischleifen;n++)
{             
PORTB=0x01;   
for(i=0; i< ifrequenz;i++)
delay_us(1);

       PORTB=0x00;            
   for(i=0; i<ifrequenz;i++)
       delay_us(1) ;
}
                                      

       if ( timeout > 0 )                
pause(timeout) ;
}


            
            

            

// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{     

/*
if ( rcvint ==1 )
       while ( PIND.2==1)
       {
       delay_ms(20) ;
       } ;      // Taste immer noch gedrückt ? Dann warten...
*/      
 rcvint=0 ;
 sleepcnt=0 ;     
 
GIFR |=0x40 ;// INT0 Flag wieder setzen
#asm("sei")// Interrupts wieder zulassen
}




// Timer 0 overflow interrupt service routine
interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{

// Reinitialize Timer 0 value
TCNT0=0xFF;                         

       if ( wdtcnt>= 65534 )
       {                 
#asm("wdr")
note(A0,T16,T10);  // C
wdtcnt=0 ;
}
wdtcnt++ ;      

}



#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)

// USART Receiver buffer
#define RX_BUFFER_SIZE 24
char rx_buffer[RX_BUFFER_SIZE];
unsigned char rx_wr_index,rx_rd_index,rx_counter;
// This flag is set on USART Receiver buffer overflow
bit rx_buffer_overflow;

// USART Receiver interrupt service routine
#pragma savereg-
interrupt [USART_RXC] void usart_rx_isr(void)
{
char status,data;
#asm
   push r26
   push r27
   push r30
   push r31
   in   r26,sreg
   push r26
#endasm
status=UCSRA;
data=UDR;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
   {
   rx_buffer[rx_wr_index]=data;
   if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0;
   if (++rx_counter == RX_BUFFER_SIZE)
     {
     rx_counter=0;
     rx_buffer_overflow=1;
     };
   };
#asm
   pop  r26
   out  sreg,r26
   pop  r31
   pop  r30
   pop  r27
   pop  r26
#endasm
sleepcnt=0 ;
}
#pragma savereg+

#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_rd_index == RX_BUFFER_SIZE) rx_rd_index=0;
#asm("cli")
--rx_counter;
#asm("sei")
return data;
}
#pragma used-
#endif



// ----------------------------------------------------------- ---------------------
// Anzeigetexte in die variablen laden.    (spart speicherplatz)
// ----------------------------------------------------------- ---------------------
void ladetexte(void)
{           
// "1234567890123456" 
strcpyf(strText[1]," Remote Control ");
strcpyf(strText[2],"   (c)05 HB.  ");

strcpyf(strText[3],"Haustuerklingel ");
strcpyf(strText[4],"   Tuer offen  ");

strcpyf(strText[5],"Tuer geschlossen");
strcpyf(strText[6]," Oeffne Tuer  ");

strcpyf(strText[7],"Person kommt... ");
strcpyf(strText[8],"               ");

strcpyf(strText[9],"               ");
strcpyf(strText[10],"                ");

strcpyf(strText[11],"Empfangsbereit  ");
strcpyf(strText[12]," sleep...       ");
                                  
strcpyf(strText[13],"oo.o..o.oo..oo.o") ; 
strcpyf(strText[14],"..o.oo.o..oo..o.") ;         
}
                    

void bewegungsmelder(char strDisplay[15])
{   
unsigned int cnt=0 ;
rcvint=1 ;                                     // Interrupt durch Receiver
while(cnt<2)
{         
if (srsoundon==1)
{
note(E2,T16,T10) ;
note(E3,T4,T10) ;
}
if (displayoff==0 )
{
lcd_clear() ;
lcd_puts(strDisplay);
lcd_gotoxy(0,1);
lcd_putsf("Bewegungsmelder !");
}
delay_ms(2000) ;
cnt++ ;
}             
while(PIND.2==0)
{
delay_ms(50) ;
}

}

void klingel(char strDisplay[15])
{                           
unsigned int cnt=0 ;

rcvint=1 ;// Interrupt durch Receiver
while(cnt<2)
{
if (srsoundon==1)
{
note(A3,T16,T10) ;
note(H3,T16,T10) ;
note(D3,T16,T10) ;
note(A2,T4,T10) ;
}
if (displayoff==0 )
{
lcd_clear() ;
lcd_puts(strDisplay);
lcd_gotoxy(0,1);
lcd_putsf("Klingel !");
}
delay_ms(2000) ;
cnt++ ;
}             

       while(PIND.2==0)              
       {
       delay_ms(50) ;
       }

}

void holezeichen(void)
{
unsigned int i=0 ;
char strbuff[24] ;
char strDisplay[15] ;
       delay_ms(500) ;// warten bis alle Zeichen da sind
              
       for (i=0;i<17;i++)
       {
strRecBuff[i]="" ;
strbuff[i]="" ;
      
       }
              
sprintf(strRecBuff,"               ") ;
sprintf(strbuff,"                ");

terminalkennung = getchar() ;// Terminalkennung aus datensatz holen

i = 0 ;
while (rx_counter>0)
{
strRecBuff[0]=getchar() ;     
if (strRecBuff[0]==0x03)// lesen bis ETX
break ;                                             

strbuff[i]=strRecBuff[0] ;
i++ ;
if (i>17)// zu viele Zeichen ? Störungen ? ETX nicht erkannt ?
{
sprintf(strbuff,"Fehler Empfang! ");
break ;
}
delay_ms(20) ;
}
                                  

sprintf(strDisplay,"Data TRS%1d",terminalkennung);  

if (strbuff[0] == DC1)
{                           
if (strbuff[1] == DC1)
bewegungsmelder(strDisplay) ;
}

if (strbuff[0] == DC2)
{             
if (strbuff[1] == DC2)
klingel(strDisplay) ;
}


if (strbuff[0] == SYN)      
{             
if (displayoff==0 )
{
lcd_clear() ;     
lcd_puts(strDisplay);
lcd_gotoxy(0,1);
lcd_putsf("SYN empfangen.");
}
}                                         

       printf("ACK");
delay_ms(500) ;
}


void init_tranceiver(void)
{     
printf("ER_CMD#R1");           // select Factory defaults
delay_ms(1000);
}


void main(void)
{

unsigned int lightcnt=0 ;

// Input/Output Ports initialization
// Port A initialization
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T
PORTA=0x00;
DDRA=0x00;

// Port B initialization
// Func0=Out Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In
// State0=0 State1=T State2=T State3=T State4=T State5=T State6=T State7=T
PORTB=0x02;
DDRB=0x03;

// Port C initialization
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T
PORTC=0x00;
DDRC=0x00;

// Port D initialization
// Func0=In Func1=In Func2=Out Func3=In Func4=In Func5=Out Func6=In Func7=In
// State0=T State1=T State2=0 State3=T State4=T State5=0 State6=T State7=T
PORTD=0x00;
DDRD=0x20;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 15,625 kHz
// Mode: Normal top=FFh
// OC0 output: Disconnected
TCCR0=0x05;
TCNT0=0xFF;
OCR0=0x00;


// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 15,625 kHz
// Mode: Ph. correct PWM top=00FFh
// OC1A output: Non-Inv.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
TCCR1A=0x81;
TCCR1B=0x02;
TCNT1H=0x00;
TCNT1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Rising Edge
// INT1: Off
// INT2: Off
GICR|=0x40;
MCUCR=0x03 ;
MCUCSR=0x00;
GIFR=0x40;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;  // 0x01 = freilaufend


// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud rate: 9600
UCSRA=0x00;
UCSRB=0x98;
UCSRC=0x86;
UBRRH=0x00;
UBRRL=0x33;  // 33;


// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
// Analog Comparator Output: Off
ACSR=0x80;
SFIOR=0x00;

// ADC initialization
// ADC Clock frequency: 125,000 kHz
// ADC Voltage Reference: Int., cap. on AREF
ADMUX=ADC_VREF_TYPE;
ADCSRA=0x87;


// Watchdog Timer initialization
// Watchdog Timer Prescaler: OSC/2048k
WDTCR=0x0F ;


                  
// Transceiver auf default Werte zurücksetzen
init_tranceiver() ;


// Display Funktion ein/aus
if ( PIND.2==1 )
{
delay_ms(200) ;
if ( PIND.2==1)
displayoff=1 ;
else
displayoff=0 ;
}

// LCD module initializationHarald
if (displayoff==0 )
{
lcd_init(16);             
ladetexte() ;
}
sleep_enable() ;      



                    
// --------------------  EEProm auslesen ------------------
if (eebcklight==255)
eebcklight=0 ;
 
if (eesoundon==255)
eesoundon=0 ;
srsoundon = eesoundon ;
srbcklight = eebcklight ;

srbcklight=1 ;
srsoundon=1 ;
// ----------------------------------------------------------- -----

rcvint=0 ;// Interrupt durch receiver zurücksetzen
      
if ( displayoff==0 )
{
if (srbcklight==1)
check_light() ;
delay_ms(100) ;
lcd_clear() ;         
}

check_fieldstrength() ;          // Empfangsfeldstärke einlesen
      
if (srsoundon==1)
{
note(C2,T16,T10);  // C                 
note(C3,T8,T10);   // C
note(A2,T8,T10);   // C
}

if ( displayoff==0 )
{
define_char(char0,0) ;    
define_char(char1,1) ;
define_char(char2,2) ;

lcd_clear() ;
lcd_puts(strText[1]);
lcd_gotoxy(0,1);
lcd_puts(strText[2]);   
delay_ms(4000) ;      
lcd_clear() ;
}
isrflag=0 ;                   

// Watchdog disable

#asm("wdr") ;
WDTCR |= (1<<0x04) | (1<<0x03) ;
WDTCR=0x00 ;
                                    

 
// Global enable interrupts
#asm("sei");                          
                    

while (1)
     {       
     check_batterie() ;            
     if (d_adc2 < 600)// Batteriespannung <= 6,0 Volt
     {                         
     note(C3,T16,T10);  // C
     note(C3,T8,T10);   // C
     lcd_clear();
     lcd_putsf("Batteriespannung");
     lcd_gotoxy(0,1);
     lcd_putsf("<= 6,0 Volt");
     delay_ms(2000) ;
     }
if (displayoff==0)
{       
lcd_gotoxy(0,0);
   lcd_puts(strText[11]);// "Erwarte Ereignis"                 
  }
  
   if (displayoff==0 )
   {
   if (lightcnt>= 50)
   {     
   if (srbcklight==1)
     check_light() ;

       check_fieldstrength() ; 
     lightcnt=0 ;
}
}
lightcnt++ ;          
                    
                  
if (displayoff==0 )
{
//sprintf(adc0,"ADC= %d        ",d_adc) ;
       sprintf(adc0,"AD=%d  %d      ",d_adc0,d_adc1) ;
lcd_gotoxy(0,1);
lcd_puts(adc0) ;            
}



/*
if (sleepcnt>=50)// ca. 2,5 Sekunden, Schlafmodus
{
lcd_clear() ;
lcd_puts(strText[1]);
lcd_gotoxy(0,1);
lcd_puts(strText[12]);
if (displayoff==0 )
{
_lcd_ready() ;
_lcd_write_data(0x8);
}
idle() ;
while(1)  
{
if ( sleepcnt == 0 )
break ;
} ;
}

*/

delay_ms(50) ;
sleepcnt++ ;
    
     if ( rx_counter > 0 ) // Commando von Schnittstelle gekommen ?
     {             
 if ( getchar() == 0x02 )// 0x02 = STX
 holezeichen() ;
  if (displayoff==0 )
   lcd_clear() ;
     }
     };
}
 

The Transmitter project:

/*********************************************
Project :  FM Transceiver
Datum    : 07.07.2005
Author : H. Brachschoss                        
Transmitter
*********************************************/

#include <mega32.h>                     
#include <delay.h>
#include <stdlib.h>
#include <stdio.h>

#define TERMINAL 0x02
#define STX 0x02
#define ETX 0x03
#define SYN 0x16
#define DC1 0x11// Device Control 1 für Bewegungsmelder
#define DC2 0x12               // Klingel
#define DC3 0x13// Ultraschall Melder

unsigned int USStatus=0 ;


// External Interrupt 1 service routine
interrupt [EXT_INT1] void ext_int1_isr(void)
{
delay_ms(100) ;
if (PIND.3 == 1 )
printf("%c%c%c%c%c",STX,TERMINAL,DC2,DC2,ETX);// Klingel Meldung übertragen.

while (PIND.3 == 1 )
delay_ms(20) ;


GIFR |=0xE0 ;// INT0 Flag wieder setzen
#asm("sei")// Interrupts wieder zulassen
}
      



// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
delay_ms(100) ;
if (PIND.2 == 1 )
printf("%c%c%c%c%c",STX,TERMINAL,DC1,DC1,ETX);// Bewegungsmelder Meldung übertragen.

while (PIND.2 == 1 )
delay_ms(20) ;


GIFR |=0xE0 ;// INT0 Flag wieder setzen
#asm("sei")// Interrupts wieder zulassen
}
      

// External Interrupt 2 service routine
interrupt [EXT_INT2] void ext_int2_isr(void)
{
delay_ms(100) ;
if (PINB.2 == 1 )
USStatus = 0 ;
//printf("%c%c%c%c%c",STX,TERMINAL,DC3,DC3,ETX);// Ultraschall Meldung übertragen.

//while (PINB.2 == 1 )
delay_ms(500) ;


GIFR |=0xE0 ;// INT0 Flag wieder setzen
#asm("sei")// Interrupts wieder zulassen
}


#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)


// USART Receiver buffer
#define RX_BUFFER_SIZE 24
char rx_buffer[RX_BUFFER_SIZE];
unsigned char rx_wr_index,rx_rd_index,rx_counter;
// This flag is set on USART Receiver buffer overflow
bit rx_buffer_overflow;

// USART Receiver interrupt service routine
#pragma savereg-
interrupt [USART_RXC] void usart_rx_isr(void)
{
char status,data;
#asm
   push r26
   push r27
   push r30
   push r31
   in   r26,sreg
   push r26
#endasm
status=UCSRA;
data=UDR;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
   {
   rx_buffer[rx_wr_index]=data;
   if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0;
   if (++rx_counter == RX_BUFFER_SIZE)
     {
     rx_counter=0;
     rx_buffer_overflow=1;
     };
   };
#asm
   pop  r26
   out  sreg,r26
   pop  r31
   pop  r30
   pop  r27
   pop  r26
#endasm
}
#pragma savereg+

#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_rd_index == RX_BUFFER_SIZE) rx_rd_index=0;
#asm("cli")
--rx_counter;
#asm("sei")
return data;
}
#pragma used-
#endif

// Standard Input/Output functions
#include <stdio.h>



void holezeichen(void)
{                       
unsigned int i=0 ;    
unsigned char strbuff[16]="" ;
                          
delay_ms(1000) ;

 while (rx_counter > 0 )
 {
 strbuff[i] = getchar() ;
 i++ ;
 delay_ms(50) ;
 }                              
      
 //if ( strbuff[0] != STX )             
 //printf("%s",strbuff) ;
}

// Declare your global variables here

void main(void)
{
    

// Input/Output Ports initialization
// Port A initialization
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T
PORTA=0x00;
DDRA=0x00;

// Port B initialization
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T
PORTB=0x00;
DDRB=0x00;

// Port C initialization
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T
PORTC=0x00;
DDRC=0x00;

// Port D initialization
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T
PORTD=0x00;
DDRD=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=FFh
// OC0 output: Disconnected
TCCR0=0x00;
TCNT0=0x00;
OCR0=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;
                            

// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Rising Edge
// INT1: On
// INT1 Mode: Rising Edge
// INT2: On
// INT2 Mode: Falling Edge
GICR|=0xE0;
MCUCR=0x0F;
MCUCSR=0x00;
GIFR=0xE0;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;

// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud rate: 19200
UCSRA=0x00;
UCSRB=0x98;
UCSRC=0x86;
UBRRH=0x00;
UBRRL=0x33;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
// Analog Comparator Output: Off
ACSR=0x80;
SFIOR=0x00;
                          

printf("ER_CMD#R1");           // select Factory defaults
delay_ms(1000) ;


// Global enable interrupts
#asm("sei")

while (1)
     {               
       if (rx_counter > 0)
       holezeichen() ;
      
/*      
     cnt++ ;
delay_ms(5000) ;
 printf("%c%cT2: %d%c",STX,TERMINAL,cnt,ETX);
if (cnt>=1000)
cnt=0 ;     
*/

delay_ms(10000) ;
printf("%c%c%c%c%c",STX,TERMINAL,SYN,SYN,ETX) ;

if ( PINB.2 == 1 )
{
delay_ms(100) ;
if ( PINB.2 == 1 )                                        
{
USStatus = 0 ;
printf("%c%c%c%c%d%c",STX,TERMINAL,DC3,DC3,USStatus, ETX) ;
}

}
else
{
USStatus=1 ;                                                    
printf("%c%c%c%c%d%c",STX,TERMINAL,DC3,DC3,USStatus, ETX) ;

}


     };
}