#include <io.h>
#include <interrupt.h>
#include <signal.h>
#include <progmem.h>

#define TRUE	1
#define FALSE	0

#define PTT 	(1<<0)
#define PTTMORSE 	(1<<1)
#define SUBTONE_D (1<<2)
#define TONE_D 	(1<<3)
#define GATE 	(1<<4)
#define MORSE	(1<<5)
#define NEW_DATA 	(1<<6)
#define PR_EN     (1<<7)

#define NO_TONE	(1<<0)
#define DISABLE	(1<<1)
#define BUSY      (1<<2)
#define NO_ROGER  (1<<3) 

#define SUBTN_INP (1<<0)
#define BUSY_INP  (1<<1)
#define TONE_INP  (1<<2)

#define BEEP_OUT  (1<<0)
#define PTT_OUT   (1<<1)
#define TONE_LED  (1<<2)
#define SUBT_LED  (1<<3)

typedef unsigned char u08;
typedef unsigned short u16;

void teleia(void);
void pavla(void);
void space(void);
void keying(u08 *);
void tone(void);
void roger(void);
//void ew(u08, u08);
//u08 er(u08);


u08 __attribute__ ((progmem)) name[] = {1,2,1,3,		//R
						    1,2,2,2,2,3,  	//1
						    3,
                                        1,2,1,1,3,		//L
                                        1,3,	     		//E
                                        1,1,2,1,3,    	//F
                                        2,1,2,3,      	//K
                                        1,2,3,        	//A
                                        2,1,1,3,      	//D
                                        1,2,3,			//A
                                        10};
                                       
u08 __attribute__ ((progmem)) okmsg[] = {2,2,2,3,		//O
                                         2,1,2,			//K
                                         10};
                                       
u08 __attribute__ ((progmem)) entrmsg[] = {1,10};       	//E
                                      
u08 __attribute__ ((progmem)) command[11][5]= {{1,2,2,1,0},	//(P)rogram
      						     {1,2,1,0,0},	//(R)eady
                                               {2,2,1,0,0}, //ro(G)er beep [en/dis]
                                               {2,1,1,0,0}, //(D)isable transmiter
                                               {2,1,0,0,0}, //to(N)e [en/dis]
                                               {1,2,0,0,0}, //en(A)ble transmiter
                                               {1,1,1,0,0}, //(S)tore & exit
                                               {1,2,2,2,2}, //NO roger beep ..(1) Subtone C 77 Hz
                                               {1,1,2,2,2}, //(2) Subtone D 82.5 Hz
                                               {1,1,1,2,2}, //(3) Subtone E 88.5 Hz
                                               {1,1,1,1,2}};//(4) Subtone F 94.8 Hz
                                               
                                             
u08 __attribute__ ((progmem)) comlen[] = {4,3,3,3,2,2,3,5,5,5,5};		
                                      
                                       
u08  cnt, cnt1, expire, cycle, beep_frequency, s, flags, j, property, upplim, lolim;
u16 delay, delay1, timer1, timer2, beep, morsedur;
u08 buffer[10];

SIGNAL(SIG_OVERFLOW0)
{
u08 p;
static u08 tt = 0, prev_in = 1;
outp(161, TCNT0);
s=inp(PORTB);
++cnt1;
if (timer1 > 50000)
    {
    timer1=0;
   // if(timer2 > 100)
   //    {
   //    timer2=0;
   //    }
   // else
       ++timer2;
    }
else
    ++timer1;
tone();
         
if (s&16)
   s=s&0xef;
else 
   s=s|16;


//if(beep > 500)
//     {
//     beep_frequency = 2;
//     tone();
//     --beep;
//     }
//else if(beep)

if (beep)
     {
     beep_frequency = 1;
     tone();
     --beep;
     }
else
    beep_frequency = 0;

p=inp(PIND);
   /****************************************************/
  /***** TONE DECONDING & MORSE DECONDING SEGMENT *****/
 /****************************************************/
if(!(p & TONE_INP))
   {
   s = s & (~TONE_LED);
   flags = flags | TONE_D;
   tt = timer2;
   flags = flags | PTT;
   ++morsedur;
   }
else
   {
   s = s | TONE_LED;
   if((morsedur > 200) && (morsedur < 2000))
     {
     buffer[j]=1;
     ++j;
     flags=flags | MORSE;
     }
   else if(morsedur > 2000)
          {
          buffer[j]=2;
          ++j;
          flags=flags | MORSE;
          }
   if((flags & MORSE) && (delay1 > 3000))
     {
     buffer[j]=3;
     ++j;
     flags=flags&(~MORSE);
     }     
   morsedur=0; 
   if(j>9) j=0;
   }   

if((!(p & BUSY_INP)) && (property & NO_TONE))
   {
   flags=flags | PTT;
   property=property | BUSY;
   }
else
   property=property &(~BUSY);
   
   /*************************************/
  /***** SUBTONE DETECTION SEGMENT *****/ 
 /*************************************/   
if((p & SUBTN_INP) && (!prev_in))
  {
  if(flags & GATE)
     flags = flags & (~GATE);
  else
     flags = flags | GATE;
  }
prev_in = p & SUBTN_INP;

   /**********************************/
  /***** SUBTONE PERIOD COUNTER *****/
 /**********************************/
if(flags & GATE)
   {
   ++cnt;
   if (cnt > upplim)   	//59
       flags = flags & (~GATE);
   }   
else {
     if(cnt > lolim)   	//oso ayxanei katebainei to anw orio 55    
       {
       if(cnt < upplim)	//oso meionetai anebainei to katw orio 59  
         {
         ++cycle;
         expire=0;
         }
       cnt=0;
       }
     else
        cnt=0;
     if(cycle > 5) //5
       {
       flags = flags | SUBTONE_D;
       flags = flags | PTT;
       s = s & (~SUBT_LED);
       cycle = 0;
       }
     if(cycle)
       {
       if(expire > 180) //180
         cycle = 0;
       else
         ++expire;
       }
     }
     
    /******************************************/
   /***** BEEP IF SUBTONE PTT WAS LET GO *****/
  /******************************************/
if((flags & SUBTONE_D) && (!cycle))
  {
  if(delay > 1000)  //1000
    {  
    flags = flags & (~SUBTONE_D);
    s = s | SUBT_LED;
    //beep = 1000;
    if(p & BUSY_INP)
      roger();
    }
  else
    ++delay;
  }
else
   delay = 0;
    
    /************************************************************/
   /***** BEEP IF TONE BURST PTT WAS LET GO OR TIME EXPIRE *****/
  /************************************************************/      
if(flags & TONE_D)
  {
  if(((timer2-tt) > 4) || (p & BUSY_INP))
    {
    flags = flags & (~TONE_D);
    //roger();
    }
  }

   
if((flags & PTT) && (!(flags & SUBTONE_D)) && (!(flags & TONE_D)) && (!(property & BUSY)))
   {
   if(delay1 > 7000)
     {
     flags = flags & (~PTT);
     }
    else
      ++delay1;
   }
else 
    delay1 = 0;


if(((flags & PTT) && (!(property & DISABLE))) || (flags & PTTMORSE))
   //s = s & (~SUBT_LED);
   s = s | PTT_OUT;
else
   s = s & (~PTT_OUT);
outp(s, PORTB);
}

int main(void)
{
u08 i = 0, n = 0,sc = 0, k=0, m, kp=20, option=0;
u08 b[10];
outp(0xff, DDRB);
outp(0, DDRD);
outp(3, PORTD);
outp((1<<TOIE0), TIMSK);
outp(158, TCNT0);
outp(2, TCCR0);
outp(0xff, PORTB);
cnt=expire=delay=delay1=cycle=cnt1=flags=property=8;
timer1=timer2=morsedur=j=0;
sei();
upplim=59;
lolim=55;
//ew(0,lolim);
//lolim=er(0);
keying(name);
for(k=0;k<6;++k)
               b[k]=0;

for(;;)
   {
    if(timer2 > 120)
      {
      keying(name);
      timer2=0;
      }
      
    // if((timer2-tim1)>120)
    //   {
    //   keying(name);
    //   tim1=timer2;
    //   }
    if(n != j)
      {
      b[i]=buffer[n];
      if(b[i]==3) 
        {
        flags=flags| NEW_DATA;
        i = j = n = 0;
        }
      else {
           ++i;
           ++n;
           if(n>=9) n=0;
           if(i>=9) i=0;
           }
      }
        
    if((j==n) && (flags & NEW_DATA))
      {
      flags=flags&(~NEW_DATA);
      for(k=0;k<=10;++k)
         {
         m=0;
         sc=0;
         while(b[m]!=3)
              {
              if(b[m]==PRG_RDB(&command[k][m]))
                ++sc;
              else
                sc=0;
              ++m;
              }
         if(sc>=PRG_RDB(&comlen[k]))
           {
           keying(entrmsg);
           //sc=0;
           break;
           }
         }          
      if((k==1) && (kp==0))
        {
        keying(okmsg);
        flags=flags|PR_EN;
        }
      else
        kp=k;
      }  

        
   if(flags & PR_EN)
     {
     switch(k)
           {
           case 2:
                 //option = option & (~NO_TONE);
                 option=property;
                 option = option ^ NO_ROGER;
                 break;
           case 3:
                 option = option | DISABLE;
                 break;
           case 4:                
                 //option = option | NO_TONE;
                 option = property;
                 option=option ^ NO_TONE;
                 break;
           case 5:
                 option = option & (~DISABLE);
                 break;
           case 6:
                 property = option;
                 flags = flags & (~PR_EN);
                 keying(okmsg);
                 break;
           case 7:
                 lolim=62;
                 upplim=67;
                 //if (property & NO_ROGER)
                 //    option=option & (~NO_ROGER);
                 //else
                 //    option=option | (NO_ROGER);
                 //option=property;
                 //option=option ^ NO_ROGER;
                 break;
           case 8:
                 lolim=59;
                 upplim=63;
                 break;
           case 9:
                 lolim=55;
                 upplim=59;
                 break;
           case 10:
                 lolim=51;
                 upplim=55;
                 break;
           }
     }      
   }
}


void teleia(void)
{
u16 dur;
dur=0;
while(dur < 19000)
     { 
     ++dur;
     beep_frequency = 1;
     }
beep_frequency = 0;
}

void pavla(void)
{
u08 i;
for (i=0; i<=2; ++i)
     teleia();
}

void space(void)
{
u16 i, a;
for(i=0; i< 19500; ++i)
    {a=i;}
}


void keying(u08 *morse)
{
u08 i=0, a;
flags = flags | PTTMORSE;
space();
space();
space();
space();
while((a=PRG_RDB(&morse[i])) != 10)
     {
     switch(a)
       {
       case 1:
           teleia();
       break;
       case 2:
           pavla();
       break;
       case 3:
            space();
            space();
            space();
       break;
       }
      space();
      ++i;
      }
flags = flags & (~PTTMORSE);
flags = flags | PTT;
}

void tone(void)
{
if(beep_frequency == 1)
         {
         if(cnt1&2)
            s=s&0xfe;
         else
            s=s|1;
         }
//      else if(beep_frequency==2)
//         {
//         if(cnt1&4)
//            s=s&0xfe;
//         else
//            s=s|1;
//         } 
	else
	   s=s&0xfe;
}


void roger(void)
{
if (!(property & NO_ROGER))
beep=300;
}

//void ew(u08 add, u08 d)
//{
//u08 a;
//outp(add, EEAR);
//outp(d, EEDR);
//outp(4, EECR);
//a=1;
//a=2;
//outp(6, EECR);
//a=3;
//a=4;
//outp(0, EECR);
//}

//u08 er(u08 add)
//{
//u08 a;
//outp(add, EEAR);
//outp(1, EECR);
//do{
//   a=inp(EECR);
//   }while(a & 1);
//a=1;
//a=inp(EEDR);
//return(a);
//}