#ifndef __int_c_
#define __int_c_


#include "int.h"


volatile unsigned char FLAGS;
volatile unsigned char FLAGS2;
volatile int YEAR;
volatile int MONTH;
volatile int DAY;
volatile int HOUR;
volatile int MINUTE;
volatile int SECOND;
volatile int MSECOND;
volatile unsigned char timer36;
volatile unsigned char thismdays;
volatile long il_last;




//values for raw move/positions,
//where 1 is representing the move
//of one minimum microstepsize, which
//is factorizied to 1/10 of an arcsecond.
volatile long calctarget_hor;
volatile long calctarget_ver;
volatile long calctarget_fr;
volatile long pos_hor;
volatile long pos_ver;
volatile long pos_fr;
volatile long origin_hor;
volatile long origin_ver;
volatile long origin_fr;
volatile long hor_360;
volatile long ver_360;
volatile long fr_360;
//-------------------------
volatile int epos_hor;
volatile int epos_ver;

volatile int originenc_hor;
volatile int originenc_ver;


volatile unsigned char spictr;
volatile unsigned char spiout[22];
volatile unsigned char spiin[22];

volatile unsigned char addr_hor;
volatile unsigned char addr_ver;
volatile unsigned char addr_fr;


//Should be called 7200 times per second.
//attention, - no blank at signalnamestart, - end
INTERRUPT(SIG_OVERFLOW0) {
	
	timer36++;

	if( timer36 == 18 ){
		//this is a 1/400tel part
		il_last++;
		if( il_last >= STARDAYSEC400LASTLONG ){
			il_last = 0;
		}
	}
	
	if( timer36 > 35 ){
		//this is also a 1/400tel part
		il_last++;
		if( il_last >= STARDAYSEC400LASTLONG ){
			il_last = 0;
		}
	
		//ok, we have a 1/200 second
		timer36 = 0;
		
		MSECOND = MSECOND + 5;
		
		if( MSECOND >= 1000 ){
			//ok, we have a complete second		
			MSECOND = 0;
			SECOND++;
			
			if( SECOND >= 60 ){
				//dito - minute
				SECOND = 0;
				MINUTE++;
				
				if( MINUTE >= 60 ){
					//hour
					MINUTE = 0;
					HOUR++;
					
					if( HOUR >= 24 ){
						//day
						HOUR = 0;
						DAY++;
						
						if( DAY > thismdays ) {
							DAY = 1;
							MONTH++;
							
							if( MONTH > 12 ){

								MONTH = 1;
								YEAR++;							
							}
						}						
					}
				}
			}
		}
	}

	/////////////////////////////////
	//here the 1/7200 stuff
	//every 1/7200 a byte is send over spi, to hold a valid frequency for the driver
	//the most time this is a nop.

	//config has to be set after startup, with followings:
	//ISFLAGSPION has to be off
	//set buffer spiout with complete config-stuff for all three boards.
	//then set ISFLAGCFG
	//then set ISFLAGSPION
	//if all send ISFLAGSPION is automatically switched of by interrupt.
	//for second config you have to do the same.
	//For normal operations, you have after all configs only to switch
	//ISFLAGSPION on.
	//addr_hor,addr_ver,addr_fr has to be init with 0xff before config.
	//the addresses for the driver-boards has to be set fixed to
	//0x00 for az/ra
	//0x01 for alt/dec
	//0x02 for fieldrotator
	//this addresses has to be set also if one, or more of them not used.
	
	if( ISFLAGSPION ){
		if( spictr == 0 ){
		
			//we use double set flags, means user handles the force-flags
			//and interrupt the internal flags, so user has not to wait
			//till interrupt is ready, - the next time spictr is 0, the
			//next priorized force-flag will be handled.
			//But have a look, that user only can set different operations
			//in one set, because the current used flag will be cleared
			//at end. In case the same flag as the previous is used, user
			//has to wait till the last is cleared by interrupt.
			//Excepting the config-functions, and the FLAGSPISTEPON,
			//the internal flags never should be used by external functions. 
		
			if( (ISFLAGSSPIFORCESEND) == 0 ){
				//we send a nop
				spiout[0]  = 0; //nop + address hor
				spiout[7]  = 1; //nop + address ver
				spiout[14] = 2; //nop + address fr
			}
			else {
			
				if( ISFLAGSPICFG ){
					//set stuff from config
					//spibuf has to contain all necessary bytes
					//Here we only set the right addresses.
					SETFLAGSPICFG;
					spiout[0]  = spiout[0]  & 0x78;
					spiout[7]  = spiout[7]  & 0x78;
					spiout[7]  = spiout[7]  + 1;
					spiout[14] = spiout[14] & 0x78;
					spiout[14] = spiout[14] + 2;
				}
			
				if( ISFLAGSPIFORCESTOP ){
					SETFLAGSPISTOP;
					CLRFLAGSPISTEPON;
					spiout[0]  = 0x20;					
					spiout[7]  = 0x21;					
					spiout[14] = 0x22;		
				}

				if( ISFLAGSPIFORCEORIGIN){
					SETFLAGSPIORIGIN;
					spiout[0]  = 0x10;					
					spiout[7]  = 0x11;					
					spiout[14] = 0x12;
					*(long *)&spiout[1]   = origin_hor;
					*(long *)&spiout[8]   = origin_ver;
					*(long *)&spiout[15]  = origin_fr;										
					*(int *)&spiout[5]    = originenc_hor;
					*(int *)&spiout[12]   = originenc_ver;
					*(int *)&spiout[19]   = 0;
				}

				if( ISFLAGSPIFORCETARGET ){
					SETFLAGSPITARGET;

					spiout[0]  = 0x08;
					spiout[7]  = 0x09;
					spiout[14] = 0x0a;

					if( ISFLAGSPISTEPON ){
						spiout[6]  = 128; //only STEP_ON (steplp is set by config)				
						spiout[13] = 128; //only STEP_ON (steplp is set by config)
						spiout[20] = 128; //only STEP_ON (steplp is set by config)
					}
					else {
						spiout[6]  = 0;				
						spiout[13] = 0;
						spiout[20] = 0;
					}
					*(long *)&spiout[1]  = calctarget_hor;
					*(long *)&spiout[8]  = calctarget_ver;
					*(long *)&spiout[15] = calctarget_fr;
				}
			}	
		}


			
		// NOW WE SEND OUT
		PORTB = PORTB & 239;//PB4 (SS) = low
		NOP;NOP;NOP;NOP;NOP;NOP; //give a little bit time

		//first store stuff from last sended byte, and clear buffer
		//the first should normally a 0xff
		spiin[spictr] = SPDR;

		NOP;NOP;

		//sendout spiout[spictr];
		SPDR = spiout[spictr];

		NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;
		PORTB = PORTB | 16;//PB4 (SS) = high
		
		spictr++;



		//Here we send the last byte of all 3 7-byte sequences		
		if( spictr > 21 ){

			spictr = 0;
			
			if( ISFLAGSPICFG ){
				addr_hor = spiin[1];
				addr_ver = spiin[8];
				addr_fr  = spiin[15];
			}
			else {
				//all others contains current pos, encpos
				pos_hor  = (long)*(long *)&spiin[1];
				pos_ver  = (long)*(long *)&spiin[8];
				pos_fr   = (long)*(long *)&spiin[15];
				epos_hor = (int)*(int *)&spiin[5];
				epos_ver = (int)*(int *)&spiin[12];											
			}


			if( ISFLAGSPISTOP ){ CLRFLAGSPIFORCESTOP; }
			if( ISFLAGSPIORIGIN ){ CLRFLAGSPIFORCEORIGIN; }
			if( ISFLAGSPITARGET ){ CLRFLAGSPIFORCETARGET; }
			if( ISFLAGSPICFG ){ CLRFLAGSPIFORCECFG; }

			CLRFLAGSSPISEND;

			if(ISFLAGSPIFORCEOFF ){
				CLRFLAGSPIFORCEOFF;
				CLRFLAGSPION;
			}
			
		}
				
	}
	
}

//END Timer-Interrupt
//timeing for the interrupt which is called every 1/7200 sec
//Every 1/7200 second part uses 0,00013333333333... seconds
//sending an spi-byte with 400kbyte/second uses 0,0000025 seconds.
//So one called interrupt hase place for max:
//max, 52 spi bytes send with 400kbytes/second, or
//max, 2040 one tact operations
//But because driver can handle all in a 1/7200 secondpart, we
//have not to wait till byte is send ready.
//a good timing-choice is to use not more then max. 500 operations





//#############################################################
//########### MOTOR ROUTINES ##################################
//#############################################################

//use SETFLAGSPISTEPON, or CLRFLAGSPISTEPON
//before if you will that motor drives to new target.
//this func is the only one which waits not till all is send
//ready, because we use the processortime for the target-calculations.
//(This is slow enough, because max. 220 times per second this function
//will be called.)
//calctarget_hor,calctarget_ver, and calctarget_fr will be set
//from this at a time, it is not bothered by interrupt.
void mot_target( long hor, long ver, long fr ) {

	if ( ISFLAGSPION ){
		
		while( ISFLAGSPITARGET ){ NOP; }
		
		calctarget_hor = hor;
		calctarget_ver = ver;
		calctarget_fr  = fr;

		SETFLAGSPIFORCETARGET;//this is cleared by interrupt automatically
	}

}


//sends a stop and set command to drivers, and waits till ready.
//after this drivers target-positons are set to dirvers current-positions,
//also the STEP_ON flags are cleared.
//After this pos_hor,pos_ver,pos_fr,epos_hor,epos_ver contain the actual
//current-position of drivers, which for the driver is also the targetpos.
void mot_stop( void ) {

	if( ISFLAGSPION ){

		while( ISFLAGSSPISEND ){ NOP; }//wait till all other is ready
		SETFLAGSPIFORCESTOP;	
		while( ISFLAGSPIFORCESTOP ){ NOP; };//wait hard, till ready	
	}
}




//first sending a mot_stop to drivers, to be sure, that
//motor does not make any step furthermore.
//then sends a origin command to all 3 drivers with the new values
//for the drivers current-positions, and encoders.
//If you will be sure, that drivers target positions are the same
//as its current position, you should be send again a mot_stop
//after this by yourself. In this case you should also be sure, that
//pos_hor,pos_ver,pos_fr, and epos_hor,epos_ver contains the origin-position.
//After this FLAGSPISTEPON is cleared, so motor does not do any step.
void mot_origin( long hor, long ver, long fr, int ehor, int ever ) {

	mot_stop();

	if( ISFLAGSPION ){

		while( ISFLAGSSPISEND ){ NOP; }//wait till all other is ready

		origin_hor   	= hor;
		origin_ver   	= ver;
		origin_fr    	= fr;
		originenc_hor  	= ehor;
		originenc_ver  	= ever;

		SETFLAGSPIFORCEORIGIN;	
		while( ISFLAGSPIFORCEORIGIN ){ NOP; };//wait hard, till ready
	}
}


//#############################################################
//########### SPI ROUTINES ####################################
//#############################################################



void spi_init(void){
	
	//initialize SPI-mode
	///////////////////////////
	//SPI-Signals will be set to MASTER by default
	//MISO(SPI-MAIN)   PB6 In   (external 47K pullup to VCC )
	//MOSI(SPI-MAOUT)  PB5 Out
	//SCK (SPI-CLKOUT) PB7 Out
	//SS  (SPI-CSOUT)  PB4 Out
	//??????????????????????????
	PORTB = 176;	//first setting pullups PB4,5,7 to high	
	DDRB  = 176;	//PB4,5,7 to output, all other unchanged
	PORTB = 176;	//these signals also to high

	//clock = f/4
	//master mode
	//enable spi
	//SCK high when idle
	
	SPCR = (1<<SPE)|(1<<MSTR)|(1<<CPOL);
	
	//(1<<SPR0) //clock f/16
	//(1<<SPR1) //clock f/64
	//(1<<SPI2X) //clock f/2
	//(1<<SPR0) //clock f/16
	//SPI2X | SPR0 fosc/8

	//(1<<CPOL) //SCK high when idle
	//(1<<CPHA) //(first)leading, or trailing(last)edge data sampling of SCK

	//clear status
	inp(SPSR);
	spiin[0] = SPDR;//clearing also buffer
}



void spi_stop(void){
	
	if( ISFLAGSPION ){
		SETFLAGSPIFORCEOFF;
		while( ISFLAGSPION ){;}//waiting hard till stopped.
	}
}



unsigned char spi_start(void){

	if( ISFLAGSPION ){
		return(1);
	}

	if( ( addr_hor != 0xff ) || ( addr_ver != 0xff ) || ( addr_fr != 0xff) ){
		SETFLAGSPION;
		return(1);
	}
	return(0);
}


//use this only after startup, when interrupt is started before.
//FLAGSPION is set by this, if all configs are ok, and min.
//one driver returns its address.
void spi_config( void )
{
	volatile unsigned char *ptr;

	spi_stop();

	addr_hor = 0xff;
	addr_ver = 0xff;
	addr_fr  = 0xff;
	
	spiout[0] = 0x48; //config 1
	ptr = (volatile unsigned char *)&hor_360;
	spiout[1] = ptr[0];
	spiout[2] = ptr[1];
	spiout[3] = ptr[2];
	spiout[4] = ptr[3];			
	ptr = (volatile unsigned char *)&cfg.ENCODERVAL_HOR;
	spiout[5] = ptr[0];
	spiout[6] = ptr[1];

	spiout[7] = 0x48; //config 1
	ptr = (volatile unsigned char *)&ver_360;
	spiout[8]  = ptr[0];
	spiout[9]  = ptr[1];
	spiout[10] = ptr[2];
	spiout[11] = ptr[3];			
	ptr = (volatile unsigned char *)&cfg.ENCODERVAL_VER;
	spiout[12] = ptr[0];
	spiout[13] = ptr[1];

	spiout[14] = 0x48; //config 1
	ptr = (volatile unsigned char *)&fr_360;
	spiout[15]  = ptr[0];
	spiout[16]  = ptr[1];
	spiout[17]  = ptr[2];
	spiout[18]  = ptr[3];			


	SETFLAGSPIFORCEOFF; //this forces a stop after sending
	SETFLAGSPIFORCECFG;
	SETFLAGSPION;
	while( ISFLAGSPION ){;}
	
	if( ( addr_hor == 0xff ) && ( addr_ver == 0xff ) && ( addr_fr == 0xff) ){
		//there is no driver board.
		return;
	}

	
	spiout[0] = 0x50; //config 2
	spiout[3] = 16;//we use Halfstep as max. value, not using fullstep
	spiout[4] = cfg.MOTORMS_HOR;			
	spiout[5] = cfg.FRQSTEP_HOR;
	spiout[6] = 0xa0; //INT_AS_FRQ, and INT_HANDLES_CMD

	spiout[7]  = 0x50; //config 2
	spiout[10] = 16;//we use Halfstep as max. value, not using fullstep
	spiout[11] = cfg.MOTORMS_VER;
	spiout[12] = cfg.FRQSTEP_VER;
	spiout[13] = 0xa0; //INT_AS_FRQ, and INT_HANDLES_CMD
	
	spiout[14] = 0x50; //config 2
	spiout[17] = 16;//we use Halfstep as max. value, not using fullstep
	spiout[18] = cfg.MOTORMS_FR;
	spiout[19] = cfg.FRQSTEP_FR;
	spiout[20] = 0xa0; //INT_AS_FRQ, and INT_HANDLES_CMD
	

	SETFLAGSPIFORCEOFF; //this forces an automatically stop after send.
	SETFLAGSPIFORCECFG;
	SETFLAGSPION;
	while( ISFLAGSPION ){;}

}




//#############################################################
//########### RTC ROUTINES ####################################
//#############################################################



void rtc_set_time( void )
{
	REAL_TIME Time;
	BYTE ret;

	cbi( TIMSK, TOIE0);//disable timer0 overflow int
	
	Time.Date      = INT2BCD(DAY);
	Time.Month     = INT2BCD(MONTH);
	Time.Year      = INT2BCD(YEAR);
	Time.Hour      = INT2BCD(HOUR);
	Time.Minute    = INT2BCD(MINUTE);
	Time.Second    = INT2BCD(SECOND);
	Time.Sec100    = INT2BCD(MSECOND / 10);

	ret = RTCSetTime( &Time, RTCDEVICEID );

	LCDPos(0,0);
						
	if( ret == RTC_SUCCESSFUL ){
		
		TCNT0 = 0;// simple setting to 0
		TCCR0 = 2;// prescaler ck/8
		timer36 = 0;//our own 7200 to 200 provider	

		//TIMSK = (1<<TOIE0);//enable timer0 overflow int
		sbi( TIMSK, TOIE0);//enable timer0 overflow int
		LCDWriteP((char *)&row_update_ok);
				
	}
	else {
		LCDWriteP((char *)&row_error);
		LCDPos(1,0);
									
		if( ret == RTC_NOT_INITIALIZED ){
			LCDWriteP((char *)&row_noinit);
		}
		
		if( ret == RTC_WRITE_ERROR ){
			LCDWriteP((char *)&row_error);
		}

		if( ret == RTC_READ_ERROR ){
			LCDWriteP((char *)&row_error);
		}

	}
	
	Delay1ms( 3000 );	
}




void rtc_get_time( void )
{
	REAL_TIME Time;
	BYTE ret;
	
	cbi( TIMSK, TOIE0);//disable timer0 overflow int
				
	ret = RTCGetTime(&Time, RTCDEVICEID );	
	if( ret == RTC_SUCCESSFUL ){

		DAY 	= BCD2INT( Time.Date );
		MONTH 	= BCD2INT( Time.Month );
		YEAR 	= BCD2INT( Time.Year );
		HOUR 	= BCD2INT( Time.Hour );
		MINUTE 	= BCD2INT( Time.Minute );
		SECOND 	= BCD2INT( Time.Second );
		MSECOND = BCD2INT( Time.Sec100) * 10;
		if( MSECOND > 995 ){
			MSECOND = 0;
		}
		thismdays = get_maxmonthdays( MONTH, YEAR );
		
		//Timer0 counting clock / 8 complete range 0-0xff
		//15745600  / 8   = 1.843.200
		//1.843.200 / 256 = 7200
		//so we have a precision of 1/7200 tel second.
		//Means the interrupt will be called 7200 times per second.
		//Because timer counts complete 8bit-range 0-255, we
		//never have to reload it with a new value.
		TCNT0 = 0;// simple setting to 0
		TCCR0 = 2;// prescaler ck/8
		timer36 = 0;//our own 7200 to 100 provider
		//TIMSK = (1<<TOIE0);//enable timer0 overflow int
		sbi( TIMSK, TOIE0);//enable timer0 overflow int
	}
	else {
		LCDPos(0,0);
		LCDWriteP((char *)&row_error);
		LCDPos(1,0);
									
		if( ret == RTC_NOT_INITIALIZED ){
			LCDWriteP((char *)&row_noinit);
		}
		
		if( ret == RTC_WRITE_ERROR ){
			LCDWriteP((char *)&row_error);
		}

		if( ret == RTC_READ_ERROR ){
			LCDWriteP((char *)&row_error);
		}
		
		Delay1ms( 3000 );				
	}		
}



//#############################################################
//########### EEPROM ROUTINES #################################
//#############################################################

void EEPROM_write( unsigned int uiAddress, unsigned char ucData )
{
	unsigned char cop;
	//For our stuff the test, if last operation is ready,
	//is normally not necessary, because whe write only
	//one byte in 1/3600 second, - but why not.
	
	while( EECR & (1<<EEWE)){;}	// 2 OP's


	//now checking the end of an interrupt, for having the
	//complete time till next interrupt is going on.
	//Interrupt changes timer36 after startup.
	//So, we will hard wait till an interrupt has changed
	//this value, for beeing sure, to pass the end of interrupt
	//directly.
	cop = timer36;
	while( cop == timer36 ){ NOP; };
	//after end of interrupt we have 1/7200 seconds = 2048 OP's
	//time till next interrupt will occure
	
	NOP;NOP;NOP;NOP;			// 4 OP's for having fun. Whatever ...

	
	EEAR = uiAddress;			// 1 OP's
	EEDR = ucData;				// 1 OP's + 5 CPU
	EECR |= (1<<EEMWE);			// 1 OP's
	EECR |= (1<<EEWE);			// 1 OP's
								//stack, and ret 2 OP's
								//
								//complete 8 OP's + 5 CPU = 13 OP's + 4 OP's saverness = 17 OP's
}


unsigned char EEPROM_read(unsigned int uiAddress)
{
	unsigned char cop;
	
	while( EECR & (1<<EEWE)){;}

	cop = timer36;
	while( cop == timer36 ){ NOP; };

	EEAR = uiAddress;
	EECR |= (1<<EERE);
	return EEDR;
}




#endif