#include<avr/io.h>
#include <avr/iom168.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <util/twi.h>
#include <util/crc16.h>
//
//#include <stdlib.h>



// Medium speed - ATMega16 //
///////////////////////////////
#define F_CPU 7372800 //Hz
///////////////////////////////
#include <util/delay.h> 
///////////////////////////////
#include "file.h"
///////////////////////////////

	UCHAR mc1=1;
	UCHAR mc2=1;
	UCHAR mc3=0;

//	GLOBAL DATA BLOCK
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

//	MSG
	UCHAR invitation[]= "ATMEGA168";
	UCHAR errEEP[6] = "errEEP";
//

/////////////////////////////////////////////////////
//	STATUS OF DOING
	UCHAR GLOBAL_STATUS_BYTE1=0;
	UCHAR GLOBAL_STATUS_BYTE2=0;

	UCHAR COMMAND=0;
/////////////////////////////////////////////////////
struct do_stuctr
	{
	UCHAR db[30];//={0};
	UCHAR bb[10]
	
	};
struct do_stuctr do_str;

#define adm_vol 12//byte
#define user_vol 5//byte

	UCHAR adm_mass[adm_vol]={0};
	UCHAR user_mass[user_vol]={0};

	UCHAR act_ant4s=0;
	UCHAR gcc_F=0;

	UINT my_summ=0;
//////////////////////////////////////////////////////
	UCHAR N_4_rd_from_J = 0;
	UCHAR N_4_wr_from_J = 0;
//////////////////////////////////////////////////////
	UCHAR mass4wr2j[16]={0};


/////////////////////////////////////////////////////
	UCHAR mass4code[10]={0};
	UCHAR received_code[10]={0};
	UCHAR last_rc[10]={0};
//+++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++
	UCHAR ant1_mass4code[10]={0};
	UCHAR ant2_mass4code[10]={0};
	UCHAR ant1_received_code[10]={0};
	UCHAR ant2_received_code[10]={0};
	UCHAR ant1_last_rc[10]={0};
	UCHAR ant2_last_rc[10]={0};
//+++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++

	UINT p2bj2 =0;
	UINT p2bj1 =0;
	UINT p2dinj1=0;
	UCHAR mass4J1[64]={0};
	UCHAR chsumm=0;
	UINT AddrIn24Cxx=0;


	//UCHAR CODE_RECEIVED=0;
	UCHAR counts4p=0;
	ULONG chkZero=0;
//	4	manager
	UCHAR sb1=0;
	UCHAR sb2=0;

	UCHAR counter4recv=0;
	UCHAR counter4rec[3]={0};

	UCHAR type_=0;

//++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++
#define begin_ 1
#define end_ 0

//++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++





//++++++++++++++++++++++++++++++++++++
//				485
//++++++++++++++++++++++++++++++++++++

	//UCHAR N_change=0;

	UCHAR N_w8ing=0;
	UCHAR T4w8ing=0;//
	
	UCHAR currPinVal=0;
	UCHAR T1=0;
#define T4w8ing1	40//

	
	UCHAR try_times=0;
#define t2try 20//

	UCHAR Tick_Flag=0;
	UCHAR Tick_ph1=0,Tick_ph2=0;

	UCHAR tmptbuffc=0;
	UCHAR my_tmpUDR=0;
//++++++++++++++++++++++++++++++++++++
//				485
//++++++++++++++++++++++++++++++++++++




//++++++++++++++++++++++++++++++++++++
//				RANDOM part
//++++++++++++++++++++++++++++++++++++

	UINT iran=0;
	UINT jran=0;
	//double summ;

#define jlow 20//
#define jhigh 30//

#define rand_a 421//
#define rand_c 1663//
#define rand_m 128//
#define max_char 32456//
//++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++

	UINT ucounts=0;
	UCHAR USARTb14chk=0;
	UCHAR USARTb24chk=0;
#define USART_t2t 300 //define how many times(systimer'CLK) will be USART_STATUS_BYTE stable 4 clean it
	//
	//
	UCHAR b1=0;
	UCHAR b2=0;
	UCHAR packed_data[10]={0};
	//UCHAR 

	UCHAR tstDTR=0;

	//

	UCHAR uc4ci=0;
	UCHAR mchantena=0;

///////////////////////////////////////
#define times2try 5
#define beleave_level 3
///////////////////////////////////////


//
/////////////////////////////////////////////////////
//	2 BYtes 4 sysmanager

	//UINT READER_4MANAGER_STATUS_BYTE =0;
	UCHAR GSpointer1=0;
	UCHAR GSpointer2=0;
	UCHAR *gccp2d_raz=0;

/////////////////////////////////////////////////////
	UCHAR *p2d1;
	UCHAR *p2d2;

	//24Cxxx part
	UINT pointer1 = 0;
	UINT pointer_2=0;
	UCHAR card_in_base =0;
	//UINT pointer2 = 0;
	UINT Num_of_rec_j1=0;
	UINT Num_of_rec_j2=0;

/////////////////////////////////////////////////////

//
struct addr_str
	{
	//UCHAR Addr_r;
	UCHAR Addr_s;
	UCHAR cmd;
	};
struct addr_str adm_str,user_str,gcc_ON,glrcc_str,gl1_bl_str,gl2_bl_str,rl1_bl_str,rl2_bl_str,bpr1_s_str,bpr2_s_str,gcc_recv_str,stopH,startH,setH,getDH,sVj1,CLR_J1,rd_J1,wr_J2,pure_rd;
//ch_mode,on_off_ps2,on_off_bpr1,on_off_bpr2,on_off_rl1,on_off_rl2,on_off_gl1,on_off_gl2,dformat,packdata,suff_str,sZinEnd,chk_crc16_str,td4kb1_str,td4kb2_str,gcc_ON,glrcc_str,gl1_bl_str,gl2_bl_str,rl1_bl_str,rl2_bl_str,bpr1_s_str,bpr2_s_str,gcc_recv_str,outs_str,usep_str,sha_str,rejim_str,active_ant_str;
//
//
	UCHAR ch2l=0;
	UINT T1Value=0;
	UCHAR get_rez=0;
	UCHAR gcci=0;
	UCHAR *gccp2d=0;
//
//	RFID
	UCHAR RFID_M=0;
	UCHAR RFID_ANT=0;
	UCHAR tmpRFID_ANT=0;
	UCHAR RFID_FORMAT=0;
	//
	UCHAR tmpPORTB=0;
	UCHAR tmpDDRB=0;
//++++++++
#define Default_Time 0x0300
//++++++++
#define READ	0x00
#define WRITE	0x01
////////////////////////////////////////

////////////////////////////////////////
//	GL1
struct LED_STR
	{
	UINT Time4OnLED;
	UINT Time4OFFLED;
	UINT TMP_UINT1_LED;
	UINT TMP_UINT2_LED;
	UCHAR Infinity_LED;
	UCHAR N_REPEAT_LED;
	//UINT povtor;
	UCHAR Begin_State_LED;

	UCHAR ID;
	
	};

struct LED_STR GL1,GL2,RL1,RL2;
struct LED_STR Beeper1,Beeper2;
struct LED_STR *p2str1,*p2str2;
//SET ID
//	GL1.ID=1;
//	GL2.ID=2;
//	RL1.ID=3;
//	RL2.ID=4;
//	Beeper1.ID=5;
//	Beeper2.ID=6;
//
#define SWITCH_ON_RL1 CLEARBIT(PORTC,0x04);
#define SWITCH_OFF_RL1 SETBIT(PORTC,0x04);
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#define SWITCH_ON_RL2 CLEARBIT(PORTC,0x08);
#define SWITCH_OFF_RL2 SETBIT(PORTC,0x08);
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#define SWITCH_ON_GL1 CLEARBIT(PORTC,0x01);
#define SWITCH_OFF_GL1 SETBIT(PORTC,0x01);
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#define SWITCH_ON_GL2 CLEARBIT(PORTC,0x02);
#define SWITCH_OFF_GL2 SETBIT(PORTC,0x02);
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#define BPR1_ON CLEARBIT(PORTD,0x10);//(PORTA,0x40);
#define BPR1_OFF SETBIT(PORTD,0x10);//(PORTA,0x40);

//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++
//	USART protocol data

//#define _def_UBRRL 0x2F
//#define _def_UBRRH 0x00


	UCHAR USART_SIGNAL_BYTE=0;
	//////////////////////////
	//UCHAR USART_CONTROL_MASS[]
	
	UCHAR Addr_sender=0;
	UCHAR Addr_recepient=0;
	UCHAR currC=0;
	UCHAR Nd=0;
	UCHAR RECcommand=0;
	UINT REC_CRC=0;

	UCHAR rCRC=0;
	
	UINT wCRC = 0xFFFF;

	union 
		{
		UINT u1;
		UCHAR m[2];
		} Name1;

	union
		{
		UINT crcuint;
		UCHAR crcb[2];
		} CRC4SEND;

//++++++++++++++++++++++++++++++++++++++++++++++++++++++
//////////////////////////////////////////////////////////////
//	HOLTEK
//////////////////////////////////////////////////////////////
struct date_str
	{
	unsigned char YEAR;//SEC;
	unsigned char DAY;//MIN;
	unsigned char MONTH;//HOUR;
	unsigned char DATE;//DATE;
	unsigned char HOUR;//MONTH;
	unsigned char MIN;//DAY;
	unsigned char SEC;//YEAR;
	};

struct date_str mds;//,date1,date2;

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//////////////////////////////////////////////////////////////
//	Define struct that will write 2 24Cxx
//////////////////////////////////////////////////////////////
/*
struct str24Cxx
	{
	//time part - length 7 byte
	unsigned char YEAR;//SEC;
	unsigned char DAY;//MIN;
	unsigned char MONTH;//HOUR;
	unsigned char DATE;//DATE;
	unsigned char HOUR;//MONTH;
	unsigned char MIN;//DAY;
	unsigned char SEC;//YEAR;
	//ant part
	UCHAR ANT;
	//code part - length 10 byte
	unsigned char code[5];
	};

struct str24Cxx Str4Wr,GLRCC,str1,str2;
*/
//////////////////////////////////////////////////////////////

//++++++++++++++++++++++++++++++++++++++++++++++++++++++
////////////////////////////////////////////////////////
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//			MACROS DEFS
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*bla bla bla*/
#define SETBIT(x,y) (x |= (y)) /* same */
#define CLEARBIT(x,y) (x &= (~y)) /* same */
#define CHECKBIT(x,y) (x & (y)) /* same */
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//		TWI Defs
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#define MAX_ITER	2//200//2//200		//
#define PAGE_SIZE	64		//page size in bytes
#define TWI_AT24xx_Device_Addr	0xa0	//TWI Hardware Addr of AT24Cxx
#define AT24CxxVolume 32768//in bytes




//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//			RFID dfes
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
///Set define for time 
//
#define A1 15//
#define A2 43//
#define A3 45//
#define A4 100//
////////////////////////
//#define FINAL 0x01
//#define C_CODE 0x04
#define OVERFLOW 0x02
////////////////////////
#define From_0_To_1 1//0
#define From_1_To_0 0//1
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//#define ant1 PB4
//#define ant2 PB5
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//////////////////////////////////////////////////////////////
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//		USART Defs
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Define proc of Stop/StartRx and Stop/StartTx
#define StopRx() CLEARBIT(UCSR0B,0x80);
///////////////////////////
#define StopTx() CLEARBIT(UCSR0B,0x20);
///////////////////////////
#define StartRx() SETBIT(UCSR0B,0x80);
///////////////////////////
#define StartTx() SETBIT(UCSR0B,0x20);
///////////////////////////
#define FULL 0x08 /* aacaia 3 : "<a_ ca?R<-_-?i ?aa_aa */

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#define REC_AA 0x01
#define REC_Addr_sender 0x02
#define REC_Addr_recepient 0x04
#define REC_Command 0x08
#define REC_N_data 0x10
#define	REC_data 0x20
#define REC_CRC16 0x40
#define REC_55 0x80
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
#define prefix 0xAA
#define suffix 0x55
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#define CHECK_DTR (PIND & 0x08);
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//	KB Defs
#define KB_CLK_LOW CLEARBIT(PORTB,0x04);
#define KB_CLK_HIGH SETBIT(PORTB,0x04);
//
#define KB_DATA_LOW CLEARBIT(PORTD,0x40);
#define KB_DATA_HIGH SETBIT(PORTD,0x40);

#define KB_KEY_ON SETBIT(PORTB,0x02);
#define KB_KEY_OFF CLEARBIT(PORTB,0x02);

		UCHAR KB_start_transmit=0;
		UCHAR kb_counts=0;//need 4 collect 16 systicks 4 make 4 ms delay
		UCHAR Gkbc=0;//global value 4 make delay between chars what need be send in kb
		UCHAR counter4s=0;
		//mass of table of scancodes
		//                       0    1    2     3    4    5    6    7    8    9    A    B    C    D    E    F  ENTER
		UCHAR kb_char_mass[17]={0x45,0x16,0x1E,0x26,0x25,0x2E,0x36,0x3D,0x3E,0x46,0x1C,0x32,0x21,0x23,0x24,0x2B,0x5A};
///////////////////////
#define SHIFT 0x12
///////////////////////
#define KB_POINTER 0x4E
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//		HOLTEK DEFS
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#define RST_LOW CLEARBIT(PORTB,0x01);
#define RST_HIGH SETBIT(PORTB,0x01);
///////////////////////////
#define IO_LOW CLEARBIT(PORTC,0x10);
#define IO_HIGH SETBIT(PORTC,0x10);
///////////////////////////
#define CLK_LOW CLEARBIT(PORTC,0x20);
#define CLK_HIGH SETBIT(PORTC,0x20);
///////////////////////////
#define HT1381_WRITE 0;
#define HT1381_READ 1;
///////////////////////////
#define seconds 0x80//0
#define minutes 0x82//2
#define hours 0x84//4
#define date 0x86//6
#define month 0x88//8
#define day 0x8A//10
#define year 0x8C//12
#define WP 0x8E//14
///////////////////////////


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++




//************************************************************
//************************************************************
//		STRUCT DEFINE
//************************************************************
//************************************************************

//////////////////////////////////////////////////////////////
//	EEPROM
//////////////////////////////////////////////////////////////
struct e2p_str
	{
	// ID part
	ULONG ID;
	UCHAR Ver;
	//adm part
	//+++++++++++++++++++++++++++
	UCHAR mode;
	UCHAR AddrDev;
	UCHAR USART_SPEED;
	UCHAR _def_UBRR0L;
	UCHAR _def_UBRR0H;
	
	//
	UCHAR BPR1;
	UCHAR BPR2;
	UCHAR RED_LED1;
	UCHAR GREEN_LED1;
	UCHAR RED_LED2;
	UCHAR GREEN_LED2;
	UCHAR rezhim;
	UCHAR active_ant;
	UCHAR delay_4_ant;
	//+++++++++++++++++++++++++++
	//user part
	UCHAR DATA_Format;
	UCHAR DataPACK;
	UCHAR Suffix;
	UCHAR Zero_SEND;
	UCHAR WR2J;
	UCHAR TIME;
	//
	UINT VOL_jdata1 ;//UCHAR VOL_jdata1 ;//volume in records -> 1rec == 16B
	//
	//CRC16 part
	UINT EEP_CRC16;

	};

struct e2p_str EEPROM_DATA;
//////////////////////////////////////////////////////////////
#define Vol_j1 16//
///
#define Vol_j2 16//
//////////////////////////////////////////////////////////////
#define EEPROM_CONFIG_INFO_VOLUME 26// +2 crc - > all == 28
//////////////////////////////////////////////////////////////
//	RFID
//////////////////////////////////////////////////////////////
struct mstr
	{

	UCHAR Flag;
	//
	UCHAR FINAL;
	UCHAR C_CODE;
	//
	UCHAR counter_INT0;//UINT counter_INT0;//
	UCHAR bit_counter;
	UCHAR direction;
	UCHAR summ;

	UCHAR HALF[5];
	UCHAR bit;
	UCHAR bit_c;
	UCHAR sincF;
	UCHAR bit_ready;
	UCHAR code[11];
	UCHAR sh_var;
	UCHAR Gcounter;
	UCHAR parity;

	};

struct mstr MANCHESTER_DECODE;

//////////////////////////////////////////////////////////////
//Define work struct for USART
//////////////////////////////////////////////////////////////
struct workStruct
{
UCHAR rbuffer[64];//RxBuff
UCHAR rbuffc;//Receive Buff counter
UCHAR tbuffer[64];//TxBuffer
UCHAR tbuffc;//Trans Buff counter
UCHAR NumForTrans;// Num of bytes 2 transmit
UCHAR NumOfTrans;//Num of current transmitted bytes

UCHAR tmprbuffc;
UCHAR tmptbuffc;

UCHAR TxFinal;//TxFinalFlag
UCHAR Full;//FullFlag

// 485 part
UCHAR _485_trans;
UCHAR _485_err;


};
struct workStruct Work;



//===============================================
//===============================================
//===============================================
/////////////////////////////////////////////////
///////////////////// I S R /////////////////////
/////////////////////////////////////////////////

/////////////////////////////////////////////////
///////////////////// I S R /////////////////////
/////////////////////////////////////////////////
SIGNAL (INT0_vect)//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;
			TCCR0B = (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
	{
	////////////////////////*****************
				TCCR0B = 0x00; //stop timer
				//CLEARBIT(GICR,0x40);
				TCNT0=00;
												
				//clr MANCHESTER_DECODE
				CLR_MANCHESTER_STR();				

				TIMSK0 |= (1<<TOIE0);;//_BV(TOIE0);
				//
				//MCUCR=3;//config int0 on rise age
				EICRA |= (1<<ISC00) | (1<<ISC01);//int 0 on rising age

				SETBIT(EIMSK,0x01);//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(EICRA,0x01);//MCUCR,0x01);//

		}
		else
		{
			
			TCNT0=0;
			MANCHESTER_DECODE.direction=From_0_To_1;
			SETBIT(EICRA,0x01);//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
	
	EIFR|=(1<<INTF0);//0x40;  -  clear int0flag
	sei();

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

	TCCR0B = 0x00; //stop timer

	if (T1Value)
	{
		//w8 is too long//
		//INT0 reconfig
		//CLEARBIT(GICR,0x40);//-  stop int0
		//MCUCR=3;//
		EICRA |= (1<<ISC00) | (1<<ISC01);//int 0 on rising age
		EIFR|=(1<<INTF0);// -  clear int0flag
		//timer reconfig
		TCNT0=00;
		TIMSK0 |=(1<<TOIE0);//_BV(TOIE0);
		// clr flags, counters
		//void CLR_MANCHESTER_STR(void)
		CLR_MANCHESTER_STR();
		CLR_M_D_c();
		SETBIT(EIMSK,0x01);//GICR,0x40);// -  start int0

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

		sei();
}
//
/////////////////////////////////////////////////
///////////////////// I S R /////////////////////
/////////////////////////////////////////////////
SIGNAL(TIMER1_COMPA_vect)//SIG_OUTPUT_COMPARE1A)
{
/////////////////////
//start SysTimer  ;-))
		cli();
/////////////////////
// check 4 bad recv
/***/
		if (USART_SIGNAL_BYTE!=0)
		{
		//+++++++++++++++++++++++++++
		//+++++++++++++++++++++++++++
		//+++++++++++++++++++++++++++
		
			/////////////////////////////////////
			if (USART_SIGNAL_BYTE==USARTb14chk)
			{
				ucounts++;
				//asm volatile ("nop");
				if (ucounts == 400)//USART_t2t)
				{
					chk_ucb();
					ucounts=0;
				}
			}
			//++++++++++++++++++++++++++
			if (USARTb14chk!=USART_SIGNAL_BYTE)
			{
				ucounts=0;
			 	USARTb14chk=USART_SIGNAL_BYTE;
			}
			//++++++++++++++++++++++++++

		//+++++++++++++++++++++++++++
		//+++++++++++++++++++++++++++
		//+++++++++++++++++++++++++++
		}
	
/***/

///////////////////////
//+++++++++++++++++++
// RFID part
//////////////////////////
//mode0
if (EEPROM_DATA.mode==0)
{
	if (T1Value > 0)
	{
		T1Value --;	
	
	}
	if (T1Value==0)
	{
		MANCHESTER_DECODE.FINAL=1;
	}

		
}
else//mode 1
{
///////////////////////
///////////////////////
///////////////////////
if (do_str.db[5])
{
	if (T1Value > 0)
	{
		T1Value --;	
	
	}
/////////////////////
//++++++++++
//	UCHAR i;
//++++++++++

	if ( (T1Value==0) || (MANCHESTER_DECODE.FINAL == 1) )
	{
	
		if(RFID_M==0)
		{
			//asm ("nop");
			if (MANCHESTER_DECODE.C_CODE)//if code was catched
			{
			//
				do_str.db[5]=0;
				do_str.db[13]=1;
				//copy code
				cpy_code();
			}
			else
			{
				T1Value=Default_Time;
				if (RFID_ANT==1) RFID_ANT=2;
				else
					RFID_ANT=1;
			}
		
			
		}
		else//RFID_M != 0
		{
			do_str.db[5]=0;
			do_str.db[13]=1;//finish
			cpy_code();
		}
		
	}
//	end RFID part
}
///////////////////////
///////////////////////
///////////////////////
}
//+++++++++++++++++++
/////////////////////

if (Tick_ph1)
{
	N_w8ing++;
}
if (Tick_ph2)
{
	T1++;
}
if (Tick_Flag)
{
	if (jran-- == 0) Tick_Flag=0;;
}


/////////////////////
//+++++++++++++++++++
// GL1 part
//PC0 pin
if (do_str.bb[1])
	{
		blink_func(&GL1);
	}


//	end GL1 part
//+++++++++++++++++++
/////////////////////

/////////////////////
//+++++++++++++++++++
// GL2 part

//PC1 pin
if (do_str.bb[2])
	{
		blink_func(&GL2);
	}

//	end GL2 part
//+++++++++++++++++++
/////////////////////

/////////////////////
//+++++++++++++++++++
// RL1 part
///////////////////
//PC1 pin
if (do_str.bb[3])
	{
		blink_func(&RL1);
	}
//	end RL1 part
//+++++++++++++++++++
/////////////////////

/////////////////////
//+++++++++++++++++++
// RL2 part
/////////////////////
//PC1 pin
if (do_str.bb[4])
	{
		blink_func(&RL2);
	}

//	end RL2 part
//+++++++++++++++++++
/////////////////////

/////////////////////
//+++++++++++++++++++
// Beeper1 part
if (do_str.bb[5])
	{
		blink_func(&Beeper1);
	}
//	end Beeper1 part
//+++++++++++++++++++
/////////////////////

/////////////////////
//+++++++++++++++++++
// Beeper2 part
if (do_str.bb[6])
	{
		blink_func(&Beeper2);
	}
//	end Beeper2 part
//+++++++++++++++++++

/////////////////////////////////////////////////////
	TCNT1=0;
/////////////////////////////////////////////////////

		sei();

}

//
/////////////////////////////////////////////////
///////////////////// I S R /////////////////////
/////////////////////////////////////////////////

/////////////////////////////////////////////////
///////////////////// I S R /////////////////////
/////////////////////////////////////////////////
SIGNAL(USART_RX_vect)//SIG_USART_RECV)
{
	cli();

	UCHAR tmpUDR=0;
	UCHAR i;
	
	if(Work.rbuffc>63)
	{
		
		SETBIT(Work.Full,FULL);
		Work.rbuffc=0;
	}
	

	tmpUDR=UDR0;

	if (CHECKBIT(USART_SIGNAL_BYTE,REC_AA))
	{
		if (CHECKBIT(USART_SIGNAL_BYTE,REC_Addr_sender))
			{
				if (CHECKBIT(USART_SIGNAL_BYTE,REC_Addr_recepient))
				{
					if (CHECKBIT(USART_SIGNAL_BYTE,REC_Command))
					{
						if (CHECKBIT(USART_SIGNAL_BYTE,REC_N_data))
						{
							if (CHECKBIT(USART_SIGNAL_BYTE,REC_data))// || (Nd==0) )
							{
								//
								//if (EEPROM_DATA.CHK_CRC16==0) SETBIT(USART_SIGNAL_BYTE,REC_CRC16);
								//
								if (CHECKBIT(USART_SIGNAL_BYTE,REC_CRC16))
								{
									if (tmpUDR==0x55) SETBIT(USART_SIGNAL_BYTE,REC_55);
									else
									{
										chk_ucb();
										//////////
									}
								}
								else
								{
									switch(currC)
									{
									case 0:
										Name1.m[1]=tmpUDR;
										rCRC=1;
										currC=1;
										break;
									case 1:
										Name1.m[0]=tmpUDR;
										currC=0;
										SETBIT(USART_SIGNAL_BYTE,REC_CRC16);

									}
								
								}	
								
								
							}
							else // catch  data proc
							{
								//if Work.rbuffc> 63 -> Work.rbuffc=0
								//cyclic buffer
								//if (Work.rbuffc>63) Work.rbuffc=0;
								Work.rbuffer[Work.rbuffc++]=tmpUDR;
								mc3++;
								if (Work.rbuffc==Nd) SETBIT(USART_SIGNAL_BYTE,REC_data);
								
							}
						}
						else
						{
							Nd=tmpUDR;
							//mc3=Nd;
							Work.rbuffc=0;
							SETBIT(USART_SIGNAL_BYTE,REC_N_data);
							if (Nd==0) SETBIT(USART_SIGNAL_BYTE,REC_data);
						}

					}
					else
					{
						RECcommand=tmpUDR;
						SETBIT(USART_SIGNAL_BYTE,REC_Command);
					}
				}
				else
				{
					Addr_recepient=tmpUDR;
					SETBIT(USART_SIGNAL_BYTE,REC_Addr_recepient);	
				}
			}
			else
			{
				Addr_sender=tmpUDR;
				SETBIT(USART_SIGNAL_BYTE,REC_Addr_sender);

			}
		
	}
	else
	{
		if (tmpUDR==prefix)
		{
			wCRC = 0xFFFF;
			rCRC=0;

			SETBIT(USART_SIGNAL_BYTE,REC_AA);//
		}
	}
/////////////////

	if ( CHECKBIT(USART_SIGNAL_BYTE,REC_AA)  && (rCRC==0) )
	{


			wCRC ^= tmpUDR;//
			for (i=0; i<8; i++)
  			{
    			if (wCRC & 1)
					wCRC = (wCRC >> 1) ^ 0xA001;
	   			else
					wCRC = (wCRC >> 1);
  			}	
		

			i=0;
	}


////////////////////
	/*
	if (USART_SIGNAL_BYTE==0b00011111)
	{
		if (mc1)
		{
			SWITCH_ON_GL2;
			mc1=0;
		}
		else
		{
			SWITCH_OFF_GL2;
			mc1=1;
		}
	}
	*/

	/*
	if ((USART_SIGNAL_BYTE==0b11111111))	
	{
		//if (Work.rbuffc) SWITCH_ON_GL2
		//else 
		//	SWITCH_OFF_GL2;
	USART_SIGNAL_BYTE=0;
	//mc3=0x30+Nd;
	//Work.rbuffc=0;


		if (mc2)
		{
			SWITCH_ON_RL2;
			mc2=0;
		}
		else
		{
			SWITCH_OFF_RL2;
			mc2=1;
		}

	}
	
	goto exit_from_udre;
	*/
////////////////////
	if ((USART_SIGNAL_BYTE==0xFF) || (USART_SIGNAL_BYTE==0xDF) )	
	{
		//mc1++;
		
		if (wCRC==Name1.u1)
		{
			USART_SIGNAL_BYTE=0;
			ucounts=0;
			Work.rbuffc=0;
			//chk_ucb
			


			//case 1://send status
			if (RECcommand==1)
			{
				//CLR
				TxBuff_Reset();
				RxBuff_Reset();
				PUT_HEAD(Addr_sender,Addr_recepient,1);
				//
				Work.tbuffer[4] = 36;//
				for (i=5;i<35;i++) Work.tbuffer[i]=do_str.db[i-5];
				for (i=35;i<41;i++) Work.tbuffer[i]=do_str.bb[i-24];
				//
				PUT_TAIL(40);
				//
				TransTxBuff(40);//N4T
			}
				
			//case 2://
			if (RECcommand==2)
			{
				//
				if (Work.rbuffer[0]==0x01)//Stop brp1 sound
				{					
					do_str.bb[5]=0;					
				}
				if (Work.rbuffer[0]==0x02)//Stop brp2 sound 
				{
					do_str.bb[6]=0;				
				}
				if (Work.rbuffer[0]==0x03)//Stop GreenLED1
				{
					do_str.bb[1]=0;
				}
				if (Work.rbuffer[0]==0x03)//Stop GreenLED2
				{
					do_str.bb[2]=0;				
				}
				if (Work.rbuffer[0]==0x03)//Stop RedLED1
				{
					do_str.bb[3]=0;				
				}
				if (Work.rbuffer[0]==0x03)//Stop RedLED2
				{
					do_str.bb[4]=0;				
				}
				if (Work.rbuffer[0]==0x04)//Stop GET_card_code in field
				{
					do_str.db[5]=0;
				}
				if (Work.rbuffer[0]==0x10)//cansel ALL
				{
					for (i=0;i<30;i++) do_str.db[i]=0;
					for (i=0;i<10;i++) do_str.bb[i]=0;
				}
				
				//CLR
				TxBuff_Reset();
				RxBuff_Reset();
				STD_ECHO(Addr_sender,Addr_recepient,2);
				//
				TransTxBuff(8);//N4T
			}

			//case 3://
			if ( RECcommand==3 )
			{
				//CLR
				TxBuff_Reset();
				RxBuff_Reset();
				PUT_HEAD(Addr_sender,Addr_recepient,3);	
				Work.tbuffer[4] = 1;
				Work.tbuffer[5]=EEPROM_DATA.AddrDev;
				PUT_TAIL(5);
				TransTxBuff(8);//N4T
			}
			

			//case 4://
			if (RECcommand==4)
			{
				TxBuff_Reset();
				RxBuff_Reset();
				PUT_HEAD(Addr_sender,Addr_recepient,4);
				Work.tbuffer[4] = 30;//sizeof(EEPROM_DATA);
				//
				gccp2d=&EEPROM_DATA;
				for (i=5;i<35;i++) Work.tbuffer[i] = *gccp2d++;
				//
				PUT_TAIL(i);
				//
				TransTxBuff(i+3);//N4T
			}
			else
			{	///////////////
				COMMAND = RECcommand;				
				///////////////
				mc2+=RECcommand;
				mc1++;
				
			}


			
		}
		else
		{
		
			///	BAD CRC
			//clear all	USART DATA BLOCK
			////////////////////////////


			chk_ucb();
			
				
		}

	}
	

	
exit_from_udre:

	sei();

}
//
/////////////////////////////////////////////////
///////////////////// I S R /////////////////////
/////////////////////////////////////////////////

/////////////////////////////////////////////////
///////////////////// I S R /////////////////////
/////////////////////////////////////////////////
//===============================================
//===============================================
//===============================================
//*************************************************************
//*************************************************************
//*************************************************************
//	FUNCTIONS
//*************************************************************
//*************************************************************
//*************************************************************

void STORE_STRUCT_2_EEPROM(UINT E2P_addr, char *p2str, UINT length)
{
/////////////////
	cli();
	
	CRC4SEND.crcuint = MakeCRC16(&EEPROM_DATA,EEPROM_CONFIG_INFO_VOLUME);//crcuint
	EEPROM_DATA.EEP_CRC16 = CRC4SEND.crcuint;
/////////////////
	while (length--)	
	{
		
		while(EECR & 0x02);//
		EEAR = 	E2P_addr++;//location
		EEDR = 	*p2str++;//byte
		asm("sbi 0x1C,2 \n"
			"sbi 0x1C,1");


	}
/////////////////
		sei();
/////////////////
}
//*************************************************************
//*************************************************************
//*************************************************************
void GET_STRUCT_FROM_EEPROM(UINT E2P_addr, char *p2str, UINT length)
{
//////////////////////
	cli();
//////////////////////
	while (length--)
	{
		//cli();
		//////////////////////
		while(EECR & 0x02);//
		//////////////////////	
		EEAR = E2P_addr++;//location;
		EECR |= (1<<EERE); //
   		while ( CHECKBIT(EECR,0x01) ) ;//
		*p2str++=EEDR;
	
	}
//////////////////////
		sei();
//////////////////////
}
//*************************************************************
//*************************************************************
//*************************************************************
void CLR_MANCHESTER_STR(void)
{
	gccp2d=&MANCHESTER_DECODE;
	for (gcci=0;gcci<sizeof(MANCHESTER_DECODE);gcci++) 
	{
		*gccp2d++=0x00;
	}
	MANCHESTER_DECODE.direction=From_0_To_1;
	ch2l=0;
}
//*************************************************************
//*************************************************************
//*************************************************************
void CLR_USART_STR(void)
{
	gccp2d=&Work;
	for (gcci=0;gcci<sizeof(Work);gcci++) 
	{
		*gccp2d++=0x00;
	}

}
//*************************************************************
//*************************************************************
//*************************************************************
void stop_INT0(void)
{
	TCCR0A = 0x00; //stop timer
	CLEARBIT(TIMSK0,0x01);//disable T0 oveflow int
	CLEARBIT(EIMSK,0x01);//GICR,0x40);//disable int0
	//
}
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************

//*************************************************************
//*************************************************************
//*************************************************************

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//*************************************************************
//*************************************************************
//*************************************************************
//send char proc
void USART_Transmit( unsigned char data )
{
/* Wait for empty transmit buffer */
while ( !( UCSR0A & (1<<UDRE0)) )
;
/* Put data into buffer, sends the data */
UDR0 = data;
}
//*************************************************************
//*************************************************************
//*************************************************************
//receive char proc
unsigned char USART_Receive( void )
{
/* Wait for data to be received */
while ( !(UCSR0A & (1<<RXC0)) )
;
/* Get and return received data from buffer */
return UDR0;
}
//*************************************************************
//*************************************************************
//*************************************************************
void rnd(void)
{
	/*
	if (iran==0)//iran==0 - first initializating
	{
		iran=TCNT1;	
	}
	*/

	iran=(iran*rand_a+rand_c)%rand_m;
}
//*************************************************************
//*************************************************************
//*************************************************************
UCHAR pANDr (void)
{
/***/
	if (try_times-- == 0) return 0;

	//+++++++++++++++++++++
	//random generator part
	rnd();
	//random generator part
	//+++++++++++++++++++++


	//now has iran range 0-63.5
	jran=iran+10;//add val for naven`t ZERO problem 4 delay

	//set flag 4 start tick
	Tick_Flag=1;
	//while (Tick_Flag) ;	
wlno2:
	if (Tick_Flag) goto wlno2;

	return 1;

/***/
}
//*************************************************************
//*************************************************************
//*************************************************************
//Get TxFinalFlag -> if 1 - haven't transmit ; if 0 - transmit in progress
UCHAR Get485Stat(void)
{
	return Work._485_trans;
}
//*************************************************************
//*************************************************************
//*************************************************************
//Routine For transmit TxBuff when it prepared externally;N4T - num for transmit
void TransTxBuff(char N4T)
{
	try_times=10;
//	start
	Work.NumForTrans=N4T;
start_trans:
	Work.tbuffc=0;
	Work._485_trans=1;

	//prepare 2 trans
	//1 - listen leg RXD while 2byte trans
	Tick_ph1=1;
	N_w8ing=0;
wll:
	currPinVal=CHECKBIT(PIND,0x01);//
	if (currPinVal==CHECKBIT(PIND,0x01))
	{
		if (N_w8ing > 100)//T4w8ing)
		{
			Tick_ph1=0;
			N_w8ing=0;
			goto contl;
		}

		goto wll;

	}
	//if change - again w8ing 
	//
	Tick_ph1=1;
	N_w8ing=0;
	//
	goto wll;
contl:
	//disable ints 4 receive 
	CLEARBIT(UCSR0B,0x80);
	//
	SETBIT(PORTD,0x08);//trans ON
	//trans byte
	////
	my_tmpUDR=UDR0;
	my_tmpUDR=0;
	////
	Work.NumOfTrans=Work.NumForTrans-Work.tbuffc;
	USART_Transmit(Work.tbuffer[Work.tbuffc++]);
	//
	Tick_ph2=1;
	T1=0;
	//w8ing Time T1 or recv ivent
w8l:
	
	if (T1 > T4w8ing1)
	{
		CLEARBIT(PORTD,0x08);//485 on receive
		//pause ans repeat
		Tick_ph2=0;
		if (pANDr())
		{
			//clean recv buffer
			//RxBuff_Reset();
			goto start_trans;
			
		}
		else
		{
			Work._485_err=1;
			Work._485_trans=0;
			goto exitfromtr;
		}
	}

	if (CHECKBIT(UCSR0A,0x80)) //0x40
	{
		my_tmpUDR=UDR0;//save UDR when recv data
		//asm volatile ("nop");
		tmptbuffc=Work.tbuffc-1;

		if (Work.tbuffer[tmptbuffc] != my_tmpUDR)//USART_Receive()
		{
			CLEARBIT(PORTD,0x08);//485 on receive
			//pause ans repeat
			Tick_ph2=0;
			if (pANDr())
			{
				//clean recv buffer
				//RxBuff_Reset();
				goto start_trans;
			
			}
			else
			{
				Work._485_err=2;
				goto exitfromtr;
			}
		}
		else//if all correct check 4 end trans end repeat
		{
			if(Work.tbuffc==Work.NumForTrans)
			{
				//StopTx();//
				Work.NumOfTrans=0xFF;
				Work.NumForTrans=0;
				Work.tbuffc=0;
				//TxBuff_Reset();
				Work._485_trans=0;
				goto exitfromtr;
			}
			goto contl;
		}
	}
	
goto w8l;
	///
	
exitfromtr:
	//asm volatile ("nop");
	Work._485_trans=0;

	SETBIT(UCSR0B,0x80);//all int back
	///
	
	///
	CLEARBIT(PORTD,0x08);//485 on receive

}
//*************************************************************
//*************************************************************
//*************************************************************
// Get Volume of RxBuffer;current value,mean without StopRx()
UCHAR GetRxVolume(void)
{

	return Work.rbuffc;
}
//*************************************************************
//*************************************************************
//*************************************************************
UCHAR GetFullStatus(void)
{
	return Work.Full;
}
//*************************************************************
//*************************************************************
//*************************************************************
//Full TxBuffer reset - with stop transmit
void TxBuff_Reset(void)
{
	StopTx();
	UCHAR rxri=0;
	for (rxri=0;rxri<63;rxri++)
	{
		Work.tbuffer[rxri]=0;
	}
	//set counter 2 ZERO
	Work.tbuffc=0;
	//StartTx();


}
//*************************************************************
//*************************************************************
//*************************************************************
//Full RxBuffer reset - with stop receive;after - receive will enabled
void RxBuff_Reset(void)
{
	
	StopRx();
	UCHAR rxri=0;
	for (rxri=0;rxri<63;rxri++)
	{
		Work.rbuffer[rxri]=0;
	}
	//set counter 2 ZERO
	Work.rbuffc=0;

	StartRx();

}
//*************************************************************
//*************************************************************
//*************************************************************
/*
// Get Num of current transmitted bytes;If equ ZERO - Transmit is currently finished
UCHAR GetN(void)
{
	if (Work.NumOfTrans==0xFF)
	{
	return 0;
	}
	else
	{
	return Work.NumOfTrans;
	}
}
*/
//*************************************************************
//*************************************************************
//*************************************************************
void USART_INIT(void)
{
//F_CLK = 7.3728
//UART0 initialize
// char size: 8 bit
// parity: Disabled
	UCSR0B = 0x00; //disable while setting baud rate
	UCSR0A = 0x00;
	UCSR0C = 0x06;
	//
	UBRR0L = EEPROM_DATA._def_UBRR0L; //set baud rate lo
 	UBRR0H = EEPROM_DATA._def_UBRR0H; //set baud rate hi
	//

	
	UCSR0B = 0x98;
}
//*************************************************************
//*************************************************************
//*************************************************************
UCHAR getRBC(void)
{
	return Work.rbuffc;
}
//*************************************************************
//*************************************************************
//*************************************************************
//
UINT    MakeCRC16( unsigned char  *pbData , UINT  wSize )//UINT wCRC ,unsigned char  *pbData)//, UINT  wSize)
{

	
	UINT wCRC = 0xFFFF;
	UCHAR i;

	while (wSize-- > 0) 
	{
	
		
		wCRC ^= *pbData++;

		for (i=0; i<8; i++)
  		{
    			
				if (wCRC & 1)
					wCRC = (wCRC >> 1) ^ 0xA001;
	   			else
					wCRC = (wCRC >> 1);
  		}	
	}

	return wCRC;

}
//*************************************************************
//*************************************************************
//*************************************************************
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
	EICRA = (1<<ISC01) | (1<<ISC01);
	EIFR|=(1<<INTF0);// -  clear int0flag
	SETBIT(EIMSK,0x01);// -  init int0


//////////////////////////////
//choose Timer 0 4 time param of signal measure
	TCCR0B = 0x00; //stop T0
	TCNT0 = 0x00;//set initial value 2  ZERO
	TIMSK0 |=(1<<TOIE0);//_BV(TOIE0);//set overflow
//////////////////////////////
//////////////////////////////
//////////////////////////////
	sei();//GLOBAL EBNABLE INTERUPTS!!!
// get out
}
//*************************************************************
//*************************************************************
//*************************************************************
UCHAR ANT (UCHAR num)//PORTC 6,7 - pins 4 choose ant 1,2
{
	UCHAR tmpNUM=0;
	//check status
	if(CHECKBIT(DDRB,0x10) && CHECKBIT(PORTB,0x10)) tmpNUM=1;//ant1 active
	if(CHECKBIT(DDRB,0x20) && CHECKBIT(PORTB,0x20)) tmpNUM=2;//ant2 active
	//
	
	if (tmpNUM==num) return 2;//ant is allready set
	//else w8 4 will be ZERO at GEN_pin; GEN_pin -> DDRB  = 0x08;
	//while (CHECKBIT(PINB,0x08)) ;//w8 while "1"
	// begin change
	if (num==1)//ant1
	{
		CLEARBIT(PORTB,0x20);
		SETBIT(PORTB,0x10);//set ant1PIN
	}
	else//ant2
	{
		CLEARBIT(PORTB,0x10);
		SETBIT(PORTB,0x20);//set ant2PIN
	}
	///Delay 4 become stable an line at rezhim 1 (at rezhim 0 nothing changes)
	if ((EEPROM_DATA.rezhim==1) || (EEPROM_DATA.mode==1)) delay_ms(EEPROM_DATA.delay_4_ant);
	

	///
	return 1;//all OK

}
//*************************************************************
//*************************************************************
//*************************************************************
void TransHT1381(UCHAR B2T1, UCHAR B2T2)
{
	UCHAR i;
	UCHAR mark1=1;
////////
//all 4 output	
	DDRC |= 0x30;//io + clk
	DDRB |= 0x01;//RST

	CLEARBIT(PORTC,0x30);
	CLEARBIT(PORTB,0x01);

////////////////

	RST_HIGH;
	_delay_us(100);
//config outs


////////
//1-st Byte
	for (i=0;i<8;i++)
	{
		if((B2T1 & mark1)!=0)
		{
			IO_HIGH;

		}
		else
		{
			IO_LOW;
		}
		_delay_us(100);
		CLK_HIGH;
		_delay_us(200);
		CLK_LOW;
		_delay_us(100);

		mark1*=2;

	
	}
//2-nd Byte
	mark1=1;
	for (i=0;i<8;i++)
	{
		if((B2T2 & mark1)!=0)
		{
			IO_HIGH;

		}
		else
		{
			IO_LOW;
		}
		_delay_us(100);
		CLK_HIGH;
		_delay_us(200);
		CLK_LOW;
		_delay_us(100);

		mark1*=2;
	}


////////
	RST_LOW;
	_delay_us(100);
////////

	//return 1;
}
////////////////////
//*************************************************************
//*************************************************************
//*************************************************************
UCHAR ReceiveHT1381(UCHAR Addr)
{
	UCHAR RetVal=0;
	UCHAR i;
	UINT mark1=1;

	DDRC |= 0x20;//clk
	DDRB |= 0x01;//rst
	//1-st stage - IO - for output
	DDRC |= 0x10;

	//CLEARBIT(PORTC,0x30);
	SETBIT(PORTC,0x30);
	SETBIT(PORTB,0x01);
	//CLEARBIT(PORTB,0x01);

/////////
	CLK_LOW;
	RST_LOW;
	_delay_ms(1);
	RST_HIGH;
	_delay_us(100);
/////////

	for (i=0;i<8;i++)
	{
			if((Addr & mark1)!=0)
			{
				IO_HIGH;

			}
			else
			{
				IO_LOW;
			}
			_delay_us(100);
			CLK_HIGH;
			if (i==7)
			{
				_delay_us(100);
				//2-nd stage - IO - for input
				CLEARBIT(DDRC,0x10);
				//CLEARBIT(PORTC,0x10);
				
				_delay_us(100);

			}
			else _delay_us(200);

			CLK_LOW;
			_delay_us(100);
			
			mark1*=2;	
	}
//Now Proc of receiving data
	mark1=1;

	//delay_us(250);
	_delay_ms(1);

	for (i=0;i<8;i++)
	{
		//read byte
		if(PINC & 0x10) SETBIT(RetVal,mark1);
		else CLEARBIT(RetVal,mark1);

		CLK_HIGH;
		_delay_us(200);
		CLK_LOW;
		_delay_us(200);
		mark1*=2;
	
	}
////////
	RST_LOW;
	
////////

	return RetVal;
}

//
//*************************************************************
//*************************************************************
//*************************************************************

void HT1380_SET_DATE(void)
{
//date str must be befor call preapared

//1-st step - enable write to HT1380
	UCHAR MyWP=0;
	MyWP= WP | HT1381_WRITE;
	
	TransHT1381(MyWP,00);
	
	UCHAR mtvar=0;
			
//2-nd step - write secs;
	mtvar=0;
	
	mtvar=seconds | HT1381_WRITE;
	TransHT1381(mtvar,mds.SEC);
//3-rd - wr mins;
	mtvar=0;

	mtvar=minutes | HT1381_WRITE;
	TransHT1381(mtvar,mds.MIN);
//4-th - wr hours;
	mtvar=0;

	mtvar=hours | HT1381_WRITE;
	TransHT1381(mtvar,mds.HOUR);
//5-th - wr date;
	mtvar=0;

	mtvar=date | HT1381_WRITE;
	TransHT1381(mtvar,mds.DATE);
//6-th - wr month;
	mtvar=0;

	mtvar=month | HT1381_WRITE;
	TransHT1381(mtvar,mds.MONTH);
//7-th - wr month;
	mtvar=0;

	mtvar=day | HT1381_WRITE;
	TransHT1381(mtvar,mds.DAY);
//8-th - wr year;
	mtvar=0;

	mtvar=year | HT1381_WRITE;
	TransHT1381(mtvar,mds.YEAR);
//9-th step - swt WR PROTECTED
	MyWP=0;
	MyWP= WP | HT1381_WRITE;
	
	TransHT1381(MyWP,0x80);

}
//*********************************************
void HT1380_GET_DATE(void)
{
//1-st - receive secs
	UCHAR mtvar=0;
	
	mtvar=seconds | HT1381_READ;
	mds.SEC=ReceiveHT1381(mtvar);
//2-nd - receive min
	mtvar=0;

	mtvar=minutes | HT1381_READ;
	mds.MIN=ReceiveHT1381(mtvar);
//3-nd - receive hours
	mtvar=0;

	mtvar=hours | HT1381_READ;
	mds.HOUR=ReceiveHT1381(mtvar);
//4-nd - receive date
	mtvar=0;

	mtvar=date | HT1381_READ;
	mds.DATE=ReceiveHT1381(mtvar);
//5-nd - receive month
	mtvar=0;

	mtvar=month | HT1381_READ;
	mds.MONTH=ReceiveHT1381(mtvar);
//6-nd - receive day
	mtvar=0;

	mtvar=day | HT1381_READ;
	mds.DAY=ReceiveHT1381(mtvar);
//7-nd - receive year
	mtvar=0;

	mtvar=year | HT1381_READ;
	mds.YEAR=ReceiveHT1381(mtvar);

}

//
//*************************************************************
//*************************************************************
//*************************************************************
void StartSysTimer()//systimer- T1,int on OCRA 
{
//TIMER1 initialize - prescale:1
// WGM: 0) Normal, TOP=0xFFFF
// desired value: 250uSec/2
// actual value: ?? //-249,973uSec (0,0%)
	TCCR1B=0x00;//stop T1
	TCCR1A=0x00;
	TCNT1=0x0000;
	OCR1A=0x0733;//0x0399;//-> 0x0733/2;
	//config ints
	TIMSK1 |=(1<<OCIE1A);
	TCCR1B |= (1<<CS10);//0x01; //start Timer

}
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//**			TWI
//*************************************************************
BOOL twi_st()
{

	switch ((TW_STATUS))//rasbor poletov
	{
		case TW_REP_START:          // OK, but should not happen 
    	case TW_START:
      		return 0;
		case TW_MT_SLA_ACK:
      		return 0;
		case TW_MT_DATA_ACK:
      		return 0;
		case TW_MR_SLA_ACK:			//OK
			return 0;
    	default:
      		return 1;
	
	}

}
//*************************************************************
//*************************************************************
//*************************************************************
BOOL twi_ph1(UINT GAddr,UCHAR SLA)
{

//+++++++++++++++++++++++++++++++++++++++++++++
	/// send start condition 
	TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN); 
  	while ((TWCR & _BV(TWINT)) == 0) ; // wait for transmission 
  	//+++++++++++++++++++++++++++++++++++++++++++++
	if (twi_st()) goto quit;
	//+++++++++++++++++++++++++++++++++++++++++++++
	// send SLA+W ----  Write Operation
	//+++++++++++++++++++++++++++++++++++++++++++++
	TWDR = SLA | TW_WRITE;
  	TWCR = _BV(TWINT) | _BV(TWEN); // clear interrupt to start transmission 
	while ((TWCR & _BV(TWINT)) == 0) ; //razbor poletov
	if (twi_st()) goto quit;
	//+++++++++++++++++++++++++++++++++++++++++++++
	// send 1-st byte addr in mem
	//+++++++++++++++++++++++++++++++++++++++++++++
	TWDR = (GAddr>>8);
  	TWCR = _BV(TWINT) | _BV(TWEN); // clear interrupt to start transmission 
  	while ((TWCR & _BV(TWINT)) == 0) ; // wait for transmission 
	if (twi_st()) goto quit;
	//+++++++++++++++++++++++++++++++++++++++++++++
	// send 2-st byte addr in mem
	//+++++++++++++++++++++++++++++++++++++++++++++
	TWDR = GAddr;
	//TWDR = eeaddr;		// low 8 bits of addr 
  	TWCR = _BV(TWINT) | _BV(TWEN); // clear interrupt to start transmission 
  	while ((TWCR & _BV(TWINT)) == 0) ; // wait for transmission 
	if (twi_st()) goto quit;

	return 0;

quit:
	return 1;

}
//*************************************************************
//*************************************************************
//*************************************************************
//Write - Myself made proc
UCHAR eeprom24CxxWriteNBytes2Page(UCHAR AddrDevice , unsigned int Npage , UCHAR InAddr, UCHAR Length, char *P2Buff, BOOL CLR)
{
	
	UCHAR NumOfLoop=0;
	UCHAR SLA=0;
	UCHAR twst;
	unsigned int GAddr=0;
	UCHAR Buf_Length;
	Buf_Length=Length;

///////////////////////////
	if ((InAddr+Length)>64 || !(InAddr+Length)) return -1;//error of ADDR
	GAddr=(Npage<<6)+InAddr;
///////////////////////////
	SLA = TWI_AT24xx_Device_Addr | ((AddrDevice & 0x07) << 1);

	if (twi_ph1(GAddr,SLA)) goto error;//quit;
	//+++++++++++++++++++++++++++++++++++++++++++++
	// Send N bytes
	//+++++++++++++++++++++++++++++++++++++++++++++

for (; Buf_Length > 0; Buf_Length--)
	{
		if (CLR) TWDR=0;
		else
			TWDR = *P2Buff++;

		TWCR = _BV(TWINT) | _BV(TWEN);		 // start transmission
		while ((TWCR & _BV(TWINT)) == 0) ; 	// wait for transmission
		if (twi_st()) goto error;
	}
	//+++++++++++++++++++++++++++++++++++++++++++++
	// Send Stop Condition
	//+++++++++++++++++++++++++++++++++++++++++++++

//quit:
	TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN); /* send stop condition */
	
	//For correct user now need form W8 cicle for w8 5mS
	_delay_ms(5); ///			!!!Delay(30);!!!! - 3mS

	return 0;//all ok

error:
	TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN); /* send stop condition */
	return 1;
}


//*************************************************************
//*************************************************************
//*************************************************************
UCHAR eep24C_WriteData(UCHAR AddrDevice, unsigned int EEPROM_Addr  , unsigned int Length , char *P2Buff , BOOL CLR)
{
	UINT Np,BeginAddr;//,TMPAddr=0;
	UINT L1=0;
	UINT dL=0;
	UCHAR check;

	char *MyP2Buff;
	MyP2Buff=P2Buff;

//Full up PageBegin;
	Np=EEPROM_Addr/PAGE_SIZE;//get Num of begin write page
	//Np=EEPROM_Addr>>6;
	BeginAddr=EEPROM_Addr-PAGE_SIZE*Np;//instr begin addr
	
	
	L1=PAGE_SIZE-BeginAddr;//PageBegin[Np+1]-EEPROM_Addr;//Len 4 write
	if (Length<=L1) L1=Length;

//write 2 eeprom
	do
	{

	check=eeprom24CxxWriteNBytes2Page(00 ,Np,BeginAddr,L1,MyP2Buff,CLR);
	if (check) return 1;
	MyP2Buff+=L1;//change p2buffer
	dL+=L1;
	Np++;
	BeginAddr=0;
	L1=Length-dL;
	if (L1>64) L1=64;

	}
	while (dL<Length);

	return 0;
}
//*************************************************************
//*************************************************************
//*************************************************************
UCHAR eep24C_ReadData (UCHAR AddrDevice ,unsigned int EEPROM_Addr, int Buf_Length, UCHAR *Buf)
{
	UCHAR twcr, n = 0;
	UCHAR rv = 0;
	UCHAR SLA=0;
	////////////////
	TWSR = 0;
	////////////////	
	//
	SLA = TWI_AT24xx_Device_Addr | ((AddrDevice & 0x07) << 1);
	//
	if (twi_ph1(EEPROM_Addr,SLA)) goto error;//quit;
	//
	TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN); 	// send (rep.) start condition
	while ((TWCR & _BV(TWINT)) == 0) ; 		// wait for transmission
	if (twi_st()) goto error;//quit;
	//
	TWDR = SLA | TW_READ;			//Send device address + read bit
	TWCR = _BV(TWINT) | _BV(TWEN);			// clear interrupt to start transmission
	while ((TWCR & _BV(TWINT)) == 0) ; 		// wait for transmission
	if (twi_st()) goto error;//quit;
	//
/////////////////////
for (twcr = _BV(TWINT) | _BV(TWEN) | _BV(TWEA); Buf_Length > 0; Buf_Length--)
	{
		if (Buf_Length == 1)
		twcr = _BV(TWINT) | _BV(TWEN); 		// send NACK this time
		TWCR = twcr;				// clear int to start transmission
		while ((TWCR & _BV(TWINT)) == 0) ; 	// wait for transmission
		switch ((TW_STATUS))
		{
			case TW_MR_DATA_NACK:
			Buf_Length = 0;			// force end of loop - FALLTHROUGH !!!
			case TW_MR_DATA_ACK:
			*Buf++ = TWDR; //rv++;		// OK, read byte
			break;
			default:
			goto error;
		}
	}

quit:
	
	TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN); 	// send stop condition

	return rv;
error:
	rv = 1;
	goto quit;
}
//*************************************************************
//*************************************************************
//*************************************************************
UCHAR eep24Cxxx(UCHAR AddrDevice, unsigned int EEPROM_Addr  , unsigned int Length , char *P2Buff , UCHAR FLAG)
{

	if (FLAG==0)//CLR proc
	{
		if (eep24C_WriteData( AddrDevice,  EEPROM_Addr  ,  Length , P2Buff , 1)==-1)
		{ 	
			TWCR=0;
			return -1;
		}
	}
	if (FLAG==1)//Write proc
	{
		if (eep24C_WriteData( AddrDevice,  EEPROM_Addr  ,  Length , P2Buff , 0)==-1)
		{
			TWCR=0;
			return -1;
		}
	}
	if (FLAG==2)//Read Proc
	{
		if (eep24C_ReadData ( AddrDevice , EEPROM_Addr, Length, P2Buff)!=1)
		{
			TWCR=0;
			return 0;	
		}
	}


	TWCR=0;
	return 1;
}
//*************************************************************
//*************************************************************
//*************************************************************
void full_UP(struct LED_STR *p2str)
{
		
		p2str->Time4OnLED = Work.rbuffer[0]; 
		p2str->Time4OnLED <<= 8;
		p2str->Time4OnLED += Work.rbuffer[1];
		
		//
		p2str->Time4OFFLED = Work.rbuffer[2]; 
		p2str->Time4OFFLED <<= 8;
		p2str->Time4OFFLED += Work.rbuffer[3];
		//////////////////////////////////
		p2str->TMP_UINT1_LED = p2str->Time4OnLED;
		p2str->TMP_UINT2_LED = p2str->Time4OFFLED;
		//
		if ( (p2str->Time4OnLED==0x00FF) && (p2str->Time4OFFLED==0x0000) ) p2str->Infinity_LED=1;
		//
		//p2str->Time4OnLED=0x0001;
		//p2str->Time4OFFLED==0x0001;
		//
		p2str->N_REPEAT_LED = Work.rbuffer[4];
		//
		p2str->Begin_State_LED = Work.rbuffer[5];
		
}
//*************************************************************
//*************************************************************
//*************************************************************

//*************************************************************
void put2struct(struct addr_str *p2adstr,UCHAR cmnd)
{
		//p2adstr->Addr_r=Addr_recepient;
		p2adstr->Addr_s=Addr_sender;
		p2adstr->cmd=cmnd;
}
//*************************************************************
//*************************************************************
//*************************************************************

//*************************************************************
//*************************************************************
//*************************************************************
void blink_func(struct LED_STR *p2str)
{
//////////////////////////
	if (p2str->Begin_State_LED)
		{
			if ( --(p2str->TMP_UINT1_LED) ==0)
			{
				p2str->Begin_State_LED=0;
				
				//check 4 led will be switch
				if(p2str->ID==1) CLEARBIT(PORTC,0x01);//GL1
				if(p2str->ID==2) CLEARBIT(PORTC,0x02);//GL2
				if(p2str->ID==3) CLEARBIT(PORTC,0x04);//RL1
				if(p2str->ID==4) CLEARBIT(PORTC,0x08);//RL2
				if(p2str->ID==5) CLEARBIT(PORTD,0x10);//Beeper1
				if(p2str->ID==6) CLEARBIT(PORTD,0x20);//Beeper2
			}

		}
		else
		{
			if ( --(p2str->TMP_UINT2_LED) ==0)
			{
				
				//check 4 led will be switch
				if(p2str->ID==1) SETBIT(PORTC,0x01);//GL1
				if(p2str->ID==2) SETBIT(PORTC,0x02);//GL2
				if(p2str->ID==3) SETBIT(PORTC,0x04);//RL1
				if(p2str->ID==4) SETBIT(PORTC,0x08);//RL2
				if(p2str->ID==5) SETBIT(PORTD,0x10);//Beeper1
				if(p2str->ID==6) SETBIT(PORTD,0x20);//Beeper2
				//
				p2str->Begin_State_LED=1;
				p2str->TMP_UINT1_LED = p2str->Time4OnLED;
				p2str->TMP_UINT2_LED = p2str->Time4OFFLED;
				//p2str->N_REPEAT_LED--;
				if (( --(p2str->N_REPEAT_LED) ==0) && (p2str->Infinity_LED==0) ) 
				{
					//return to begin state
					if(p2str->ID==1) 
					{
						SETBIT(PORTC,0x01);//GL1
						do_str.bb[1]=0;
						//if (EEPROM_DATA.mode) do_str.db[15];//SETBIT(doing_byte4,0x10);
					}
					if(p2str->ID==2) 
					{
						SETBIT(PORTC,0x02);//GL2
						do_str.bb[2]=0;
						//if (EEPROM_DATA.mode) do_str.db[16];//SETBIT(doing_byte4,0x20);
					}
					if(p2str->ID==3) 
					{
						SETBIT(PORTC,0x04);//RL1
						do_str.bb[3]=0;
						//if (EEPROM_DATA.mode) do_str.db[17];//SETBIT(doing_byte4,0x40);
					}
					if(p2str->ID==4) 
					{
						SETBIT(PORTC,0x08);//RL2
						do_str.bb[4]=0;
						//if (EEPROM_DATA.mode) do_str.db[18];//SETBIT(doing_byte4,0x80);

					}
					if(p2str->ID==5) 
					{
						SETBIT(PORTD,0x10);//BPR1
						do_str.bb[5]=0;
						//if (EEPROM_DATA.mode) do_str.db[19];//SETBIT(doing_byte5,0x01);


					}
					if(p2str->ID==6) 
					{
						SETBIT(PORTD,0x20);//BPR2
						do_str.bb[6]=0;
						//if (EEPROM_DATA.mode) do_str.db[20];//SETBIT(doing_byte5,0x02);

					}
					

				}


			}
		}

//////////////////////////
}

//*************************************************************
//*************************************************************
//*************************************************************
void delay_ms(UCHAR param)
{
	UCHAR i;
	for (i=0;i<param;i++) _delay_ms(1);
}
//*************************************************************
//*************************************************************
//*************************************************************
void delay_us(UCHAR param)
{
	UCHAR i;
	for (i=0;i<param;i++) _delay_us(1);
}
//*************************************************************
//*************************************************************
//*************************************************************
void clr_cmd(void)
{
	COMMAND = 0x00;
}
//*************************************************************
//*************************************************************
//*************************************************************
void cpy_vol(UCHAR *p2bd,UCHAR *p2dd,UCHAR length)
{
	UCHAR i;
	for (i=0;i<length;i++)
	{
		*p2dd++=*p2bd++;
	}
}
//*************************************************************
//*************************************************************
//*************************************************************
//////////

//*************************************************************
//*************************************************************
//*************************************************************
UCHAR cmd_data(UCHAR *p2d1,UCHAR *p2d2,UCHAR length)// ZERO - equ,1 - high,2- low
{
	UCHAR i;
	UCHAR retval=0,tsts_val=0;;
	UCHAR *tmpp1,*tmpp2;
	tmpp1=p2d1;
	tmpp2=p2d2;
	//stage1 - high
	for (i=0;i<length;i++)
	{
		if (*tmpp1++ > *tmpp2++) 
		{
			retval=1;
			goto ext_cmp_p;//stage2;
		}
	}
stage2://stage2 - equ
	for (i=0;i<length;i++)
	{
		if (*p2d1++ == *p2d2++) 
		{
			//retval=2;
			tsts_val++;
			//goto stage2;
		}
	}
	if (tsts_val==5) retval=0;
	else
		retval=2;
ext_cmp_p:
	return retval;
}
//*************************************************************
//*************************************************************
//*************************************************************
UCHAR chk_rec (void)
{
	UCHAR i;
	UINT pofrec=0;
	card_in_base=0;
	//1-st stage - prepare code
	pack_rdata(&received_code[0]);
	//now code is packed - prepared!
	//read 1-st rec
	pointer_2=p2bj2;
rd_proc:
	// proc of reading
	eep24Cxxx(0x00,pointer_2,Vol_j2,&mass4wr2j[0],2);
	// proc of reading
	//UCHAR cmd_data(UCHAR *p2d1,UCHAR *p2d2,UCHAR length)// ZERO - equ,1 - high,2- low
	//catch code - ned be EQU
	if (cmd_data(&packed_data[0],&mass4wr2j[11],5)==0)
	{
		card_in_base=1;
		goto end_rd;
	}
	else
	{
		pofrec++;
		if (pofrec==Num_of_rec_j2) goto end_rd;
		//reconfig and goto rd_proc
		pointer_2+=Vol_j2;
		//chk 4 end of memif 
		//if (pointer_2 >= 0xFFFF)//vol of 24c256
		//{
		//	card_in_base=2;
		//	goto end_rd;
		//}
		//
		goto rd_proc;
	}

end_rd:
	
	if (card_in_base==1)//card in base
	{
		//
		SWITCH_ON_GL1;
		//
		//write operation
		///////////////////////////////////////
		//clr mass4wr2j befor work
		for (i=0;i<16;i++) mass4wr2j[i]=0;
		//clr mds
		p2d1=&mds;
		for (i=0;i<7;i++) *p2d1++=0;
		HT1380_GET_DATE();
		//code - in packed_data
		if (EEPROM_DATA.DataPACK==0)//pack is OFF
		{
		//pack_data();
		pack_rdata(&received_code[0]);
		}
		//put time
		p2d1=&mds;
		for (i=0;i<7;i++) mass4wr2j[i]=*p2d1++;
		//put ant
		mass4wr2j[7]=RFID_ANT;
		//put code
		for (i=8;i<13;i++) mass4wr2j[i]=packed_data[i-8];
		//proc of write
		//NOW Str4Wr is prepare 
		eep24Cxxx(0x00,pointer1,Vol_j1,&mass4wr2j[0],1);
		//write marker
		///////////////
		//p2d1=&mass4wr2j[0];
		for (i=0;i<16;i++) mass4wr2j[i]=0;
		if (pointer1==p2bj2-Vol_j1)
		{
			pointer1 =0x0000;
			eep24Cxxx(0x00,pointer1,Vol_j1,&mass4wr2j[0],1);
			goto end_pr;
		}
		else
			eep24Cxxx(0x00,pointer1+Vol_j1,Vol_j1,&mass4wr2j[0],1);
		//inc pointer 
		pointer1+=Vol_j1;
		//
	end_pr:
		//
		SWITCH_OFF_GL1;
		//
		return 1;
		//asm volatile ("nop");
		///***make sound***//
		
	}
	else//card hasn`t in base
	{
		//err operation
		return 0;
	}


}
//*************************************************************
//*************************************************************
//*************************************************************
UCHAR cmp_code(void)
{
	UCHAR i;
	for (i=0;i<10;i++)
	{
		if (RFID_ANT==1)
		{
			if (ant1_received_code[i] != ant1_mass4code[i]) return 1;
		}
		if (RFID_ANT==2)
		{
			if (ant2_received_code[i] != ant2_mass4code[i]) return 1;
		}
	}

	return 0;
	
}

//*************************************************************
//*************************************************************
//*************************************************************
UCHAR chk_MANCHESTER_code()
{
	ch2l = MANCHESTER_DECODE.code[0];
	UCHAR i;
	for (i=1;i<10;i++) 
	{
			ch2l^=MANCHESTER_DECODE.code[i];
	}
	if (ch2l==MANCHESTER_DECODE.code[10]) return 1;
	else 
		return 0;


}
//*************************************************************
//*************************************************************
//*************************************************************
void pack_data(void)
{
	UCHAR i,j;
	b1=0;
	b2=0;
	i=0;
	j=0;
	do
	{
	b1=(MANCHESTER_DECODE.code[i++]<<4);
	b1+=MANCHESTER_DECODE.code[i++];
	packed_data[j++]=b1;
	//i+=2;
	}
	while (i<10);

	
}
//*************************************************************
//*************************************************************
//*************************************************************
void unpack_data(void)//UCHAR *p2d1,UCHAR *p2d2,UCHAR length)
{
	UCHAR i,j,val;
	b1=0;
	b2=0;
	i=0;
	j=0;
	do
	{
		b1=(packed_data[i]>>4);
		b2=(packed_data[i++] & 0x0F);

	
		mass4code[j++]=b1;
		mass4code[j++]=b2;
	}
	while (i<5);
}
//*************************************************************
//*************************************************************
//*************************************************************
void pack_rdata(UCHAR *p2mass)
{
	UCHAR i,j;
	b2=0;
	i=0;
	j=0;
	do
	{
		b2=(*p2mass++ << 4);
		b2+=*p2mass++;
		packed_data[j++]=b2;
		//i+=2;
	}
	while (j<5);
}
//*************************************************************
//*************************************************************
//*************************************************************
UCHAR hex2char(UCHAR data)
{
	//UCHAR rd=0;
	if (data>9)//chars
	{
		return (data+0x31);
	}
	else//nums
	{
		return (data+0x30);
	}

}
//*************************************************************
//*************************************************************
//*************************************************************

//*************************************************************
//*************************************************************
//*************************************************************

//*************************************************************
//*************************************************************
//*************************************************************

//*************************************************************
//*************************************************************
//*************************************************************

//*************************************************************
//*************************************************************
//*************************************************************
void chk_ucb(void)
{
			//clear all	USART DATA BLOCK
			////////////////////////////
			USART_SIGNAL_BYTE=0;
			Addr_sender=0;
			Addr_recepient=0;
			currC=0;
			Nd=0;
			RECcommand=0;
			REC_CRC=0;
			rCRC=0;
			wCRC = 0xFFFF;
			CRC4SEND.crcuint =0;
			//TxBuff_Reset();
			RxBuff_Reset();
			//++++++++++++++++++++++++++
			

}
//*************************************************************
//*************************************************************
//*************************************************************
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
	
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//*************************************************************
//*************************************************************
//*************************************************************
void Zmsp(void)//UCHAR type)
{
	GSpointer1=0;
	GSpointer2=0;
//+++++++++++++++++++++++
//save at journal proc
if (EEPROM_DATA.WR2J)
{

	if (gcc_F==0) chk_rec();
}
//+++++++++++++++++++++++
	//SWITCH_ON_GL1;
					if (gcc_ON.cmd==0 && glrcc_str.cmd==0)
						PUT_HEAD(EEPROM_DATA.AddrDev,0xFF,0x80);
					//+++++++++++++++++++++++
					if (gcc_ON.cmd)
					{
						PUT_HEAD(EEPROM_DATA.AddrDev,gcc_ON.Addr_s,gcc_ON.cmd);
						gcc_ON.cmd=0;
						gcc_ON.Addr_s=0;
					 }
					if (glrcc_str.cmd) 
					{
						PUT_HEAD(EEPROM_DATA.AddrDev,glrcc_str.Addr_s,glrcc_str.cmd);
						glrcc_str.Addr_s=0;
						glrcc_str.cmd=0;
					}
					
					//Work.tbuffer[0]=prefix;
					//Work.tbuffer[1]=EEPROM_DATA.AddrDev;
					Work.tbuffer[4]=3;//+sizeof(mass4code);							
					if (EEPROM_DATA.DataPACK) Work.tbuffer[4]+=5;
					else
						Work.tbuffer[4]+=10;
					//put ant
					GSpointer1=PUT_ANT(5);
					if (EEPROM_DATA.TIME) GSpointer2=PUT_TIME(GSpointer1,1);
					GSpointer2=PUT_CODE(GSpointer2);//,type);
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//form_tail:
		PUT_TAIL(--GSpointer2);
		GSpointer2+=3;
////init send
	TransTxBuff(++GSpointer2);//N4T
///////////////////////////////////
endsp:
	asm volatile ("nop");
		
}
//*************************************************************
//*************************************************************
//*************************************************************
void CLR_M_D_c(void)
{
	UCHAR i;
	for (i=0;i<11;i++) MANCHESTER_DECODE.code[i]=0;	
}
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************

//*************************************************************
//*************************************************************
//*************************************************************
void cpy_code(void)
{
	UCHAR i;
	for (i=0;i<10;i++) received_code[i]=MANCHESTER_DECODE.code[i];
}
//*************************************************************
//*************************************************************
//*************************************************************
void start_gen(void)
{
	/////////////////////////////
	//	config and start GEN(***T2***)
	PORTB |= 0x08;
 	DDRB  |= 0x08;
	//start generator T2 - Freq ==125kHz
	TCCR2B=0;
	ASSR=0x00;
	TCCR2A |= (1<<COM2A0)|(1<<WGM21);
	OCR2A  = 0x1D;
	TCCR2B |= (1<<CS20);

}
//*************************************************************
//*************************************************************
//*************************************************************
void stop_gen(void)
{
	TCCR2A = 0x00; //stop
}
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************

//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************