/////////////////////////////////////////////////
///////////////////// I S R /////////////////////
/////////////////////////////////////////////////
SIGNAL (SIG_INTERRUPT0)
{
	cli();
	UCHAR TMPVal=0;
	UCHAR i;

	if (MANCHESTER_DECODE.C_CODE) goto close_int0;

	if (MANCHESTER_DECODE.counter_INT0==0)
	{
			MANCHESTER_DECODE.HALF[MANCHESTER_DECODE.bit_c++]=MANCHESTER_DECODE.direction;
			MANCHESTER_DECODE.counter_INT0=1;//
			
			//timer 2 config
			TCNT0=0;
			TCCR0 = (1<<CS01) | (1<<CS00);// //start - normal mode, Timer Freq == Fclk/64;
			goto ex1;//normal_exit_INT0;
	}
	
	TMPVal=TCNT0;

//case 1  --  A1<TMPVal<A2
	if ((TMPVal<A2) && (TMPVal>A1))
	{
		MANCHESTER_DECODE.HALF[MANCHESTER_DECODE.bit_c++]=MANCHESTER_DECODE.direction;
		goto normal_exit_INT0;
	}
//case 2  --  A3<TMPVal<A4
	if ((TMPVal<A4) && (TMPVal>A3))
	{
			MANCHESTER_DECODE.HALF[MANCHESTER_DECODE.bit_c++]=MANCHESTER_DECODE.direction;
			MANCHESTER_DECODE.HALF[MANCHESTER_DECODE.bit_c++]=MANCHESTER_DECODE.direction;

			goto normal_exit_INT0;
	}

//case 3 -- TMPVal>A4
	if (TMPVal>A4) //if  TMPVal>A4   -   reconfig all and begin from BEGIN
	{
	////////////////////////*****************
				TCCR0 = 0x00; //stop timer
				CLEARBIT(GICR,0x40);
				TCNT0=00;
												
				//clr MANCHESTER_DECODE
				CLR_MANCHESTER_STR();				

				TIMSK |=_BV(TOIE0);
				//
				MCUCR=3;
				SETBIT(GICR,0x40);//GICR|=(1<<INT0);//0x40;  -  init int0
				
	////////////////////////*****************
	}


	goto bad_exit_INT0;

normal_exit_INT0:
/////////////////////////////////////////////////
// BLOCK 4 BIT receive
	MANCHESTER_DECODE.bit_ready=0;
	MANCHESTER_DECODE.bit=0;

	if (MANCHESTER_DECODE.bit_c > 1)
	{
		//if ()
		if ( (MANCHESTER_DECODE.HALF[0]==0) && (MANCHESTER_DECODE.HALF[1]==0))
		{
			MANCHESTER_DECODE.HALF[0]=0;
			MANCHESTER_DECODE.HALF[1]=0;
			MANCHESTER_DECODE.HALF[2]=0;
			MANCHESTER_DECODE.bit_c=1;
			goto emp0gb;

		}
		if ( (MANCHESTER_DECODE.HALF[0]==1) && (MANCHESTER_DECODE.HALF[1]==1))
		{
			MANCHESTER_DECODE.HALF[0]=1;
			MANCHESTER_DECODE.HALF[1]=0;
			MANCHESTER_DECODE.HALF[2]=0;
			MANCHESTER_DECODE.bit_c=1;
			goto emp0gb;
		}

		//case 1 - setbit
		if ( (MANCHESTER_DECODE.HALF[0]==0) && (MANCHESTER_DECODE.HALF[1]==1))
		{
		
			MANCHESTER_DECODE.bit=1;
			MANCHESTER_DECODE.bit_ready=1;
		}
		//case 2 - clearbit
		if ((MANCHESTER_DECODE.HALF[0]==1) && (MANCHESTER_DECODE.HALF[1]==0))
		{
		
			MANCHESTER_DECODE.bit=0;
			MANCHESTER_DECODE.bit_ready=1;
		}
		//case 3 - receive LONG
		if (MANCHESTER_DECODE.bit_c>2)
		{
			MANCHESTER_DECODE.HALF[0]=0;
			MANCHESTER_DECODE.HALF[1]=0;
			MANCHESTER_DECODE.HALF[0]=MANCHESTER_DECODE.HALF[2];
			MANCHESTER_DECODE.HALF[2]=0;
			MANCHESTER_DECODE.bit_c=1;
			goto emp0gb;
		} 
		
		MANCHESTER_DECODE.bit_c=0;
	emp0gb:
		asm volatile ("nop");//i=0;

	}
// FINAL
/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////
	if ( MANCHESTER_DECODE.bit_ready && (MANCHESTER_DECODE.sincF==0))
	{
		if (MANCHESTER_DECODE.bit==1) MANCHESTER_DECODE.summ++;
		else MANCHESTER_DECODE.summ=0;

		
		if (MANCHESTER_DECODE.summ==9) 
		{
			MANCHESTER_DECODE.sincF=1;
			MANCHESTER_DECODE.bit_ready=0;
			
			MANCHESTER_DECODE.sh_var=0;
			MANCHESTER_DECODE.Gcounter=0;
			MANCHESTER_DECODE.parity=0;
			CLR_M_D_c();//

		}


	}
/////////////////////////////////////////////////
	if (MANCHESTER_DECODE.bit_ready && MANCHESTER_DECODE.sincF)
	{
		//case 1  -  collect bits
			if (MANCHESTER_DECODE.sh_var<4)
			{
				MANCHESTER_DECODE.code[MANCHESTER_DECODE.Gcounter]=(MANCHESTER_DECODE.code[MANCHESTER_DECODE.Gcounter]<<1);
				MANCHESTER_DECODE.code[MANCHESTER_DECODE.Gcounter]+=MANCHESTER_DECODE.bit;
			
				MANCHESTER_DECODE.sh_var++;
				MANCHESTER_DECODE.parity^=MANCHESTER_DECODE.bit;
			}
			else//case 2 - collect databits finish -NOW check parity
			{
				MANCHESTER_DECODE.sh_var=0;
				MANCHESTER_DECODE.Gcounter++;
				//++++++++++++++++++++++++++
				if (MANCHESTER_DECODE.Gcounter==11)
				{
					//
					if (chk_MANCHESTER_code())
					{
						goto finish_gcc_proc;
					}
					else
					{
						MANCHESTER_DECODE.sincF=0;
						MANCHESTER_DECODE.parity=0;
						MANCHESTER_DECODE.sh_var=0;
						MANCHESTER_DECODE.Gcounter=0;
						CLR_M_D_c();//for (i=0;i<11;i++) MANCHESTER_DECODE.code[i]=0;
						goto bad_exit_INT0;
					}
					

				}
				//++++++++++++++++++++++++++
				if (MANCHESTER_DECODE.parity!=MANCHESTER_DECODE.bit) 
				{
					MANCHESTER_DECODE.sincF=0;
					MANCHESTER_DECODE.parity=0;
					MANCHESTER_DECODE.sh_var=0;
					MANCHESTER_DECODE.Gcounter=0;
					CLR_M_D_c();//for (i=0;i<11;i++) MANCHESTER_DECODE.code[i]=0;

				}
				else 
				{
					MANCHESTER_DECODE.parity=0;
				}
				if (1==0)
				{
				finish_gcc_proc:
					stop_INT0();
					MANCHESTER_DECODE.C_CODE=1;
					MANCHESTER_DECODE.FINAL=1;
					
				}

			}
	}
	
/////////////////////////////////////////////////////////////////////////////
//END of BLOCK 4 BIT receive
/////////////////////////////////////////////////

ex1:	

	if (T1Value)//
	{
		//reconfig block

		if (MANCHESTER_DECODE.direction==From_0_To_1)
		{
			TCNT0=0;
			MANCHESTER_DECODE.direction=From_1_To_0;
			CLEARBIT(MCUCR,0x01);//

		}
		else
		{
			
			TCNT0=0;
			MANCHESTER_DECODE.direction=From_0_To_1;
			SETBIT(MCUCR,0x01);//
	
		}
	}
	else
	{
	close_int0:
		// - close all and set flag
		stop_INT0();
		///set final flag
		MANCHESTER_DECODE.FINAL=1;
	}





bad_exit_INT0:

/// CLR INT0_flag it SET when body is processed
	
	GIFR|=(1<<INTF0);//0x40;  -  clear int0flag
	sei();

}
//
/////////////////////////////////////////////////
///////////////////// I S R /////////////////////
/////////////////////////////////////////////////
SIGNAL(SIG_OVERFLOW0)//
{
	cli();

	TCCR0 = 0x00; //stop timer

	if (T1Value)
	{
		//w8 is too long//
		//INT0 reconfig
		CLEARBIT(GICR,0x40);//-  stop int0
		MCUCR=3;//
		GIFR|=(1<<INTF0);// -  clear int0flag
		//timer reconfig
		TCNT0=00;
		TIMSK |=_BV(TOIE0);
		// clr flags, counters
		//void CLR_MANCHESTER_STR(void)
		CLR_MANCHESTER_STR();
		CLR_M_D_c();
		SETBIT(GICR,0x40);// -  start int0

	}
	else
	{
		stop_INT0();
		MANCHESTER_DECODE.FINAL=1;
	}

		sei();
}
//
/////////////////////////////////////////////////
///////////////////// I S R /////////////////////
/////////////////////////////////////////////////

//**********************************************************************
void Start_Get_Card_Code(void)//
{
	//code not received yet
	//CODE_RECEIVED=0;

		cli();
/////////////////////////////
// Reset systimer on start
	TCCR1B=0;
	TCNT1=0x0000;
	TCCR1B = 0x01; //start Timer


// Prepare Structure - CLR_ALL
	CLR_MANCHESTER_STR();
// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Rising Edge
// INT1: Off
// INT2: Off
	MCUCR= 3;// rising age
	MCUCSR=0x00;//disable int 2
	GIFR|=(1<<INTF0);// -  clear int0flag
	SETBIT(GICR,0x40);// -  init int0

//////////////////////////////
//choose Timer 0 4 time param of signal measure
	TCCR0 = 0x00; //stop T0
	TCNT0 = 0x00;//set initial value 2  ZERO
	TIMSK |=_BV(TOIE0);//set overflow
//////////////////////////////
//////////////////////////////
//////////////////////////////
	sei();//GLOBAL EBNABLE INTERUPTS!!!
// get out
}