#include "dds.h"
#include "analog.h"
#include "rs232.h"
#include "util.h"
#include "gpio.h"
#include "nvm.h"
#include "ecriture.h"
#include "historique.h"
#include "isr.h"
#include "core_uart_apb.h"
#include "core_timer.h"
#include "led.h"
#include "coreai.h"
#include "stdio.h"

#define MARGE_MAX_N1	128 // valeur de declenchement de l'enregistrement de la calib (detection du max de N1)s

extern char etape_temperature;
extern char test_active; 



int n1_max = 0, n1_min = 0;
int premier_n1 = -1; // offset du n1 par rapport a la memoire
int offsetN2 = 0; // correction numerique du N2

// coefficient du PI
int K = 3 * PRECISION_PID;
int I = 5; // 5 = 0.05 

// * Timer 0 instance data.
timer_instance_t g_timer0;

// Timer interrupt service routine.
//
void timer_isr( void )
{
	int val2=0;
	int i=0;
	int j=0;
	int value;
	int n2,K_value,I_value_temp;
//	int value_n,value_p;
	static int I_value = 0;
	char txt[80];
	static short cpt=0;
	static char cpt2=0;
	static int n1;
	static int freq;
	static unsigned long long freqfiltre=0;
	int val=0;
	int z=1;
	float w0=0.0628;
	float b;
	float a;
	float c;
	float d;
	unsigned long long n1tm1=0;
	unsigned long long n1tm2=0;
	
	
	static int temp_n1 = 0,temp_n2 = 0, temp = 0;
	static int buffer_n1[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
	static unsigned char indice_buffer_n1 = 0;
	
	static int tabtm1[1] = {0};
	static unsigned char tm1_n1 = 0;
	
	static int tabtm2[1] = {0};
	static unsigned char tm2_n1 = 0;

	// recuperation du N1
	lock_N1();
	n1=read_gpio0();
//	value = read_gpio1();
	unlock_N1();
	
	
	b=1/(w0*w0);
	a=(2*z)/(w0);
	c=(1+a+b);
	d=(a+2*b);
	
	
	
			n1tm1 = tabtm1[0];
			
			for (i=0; i<2 ;i++)
				val= freqfiltre;
				tabtm1[tm1_n1++] = val;
				
			if(tm1_n1 == 1)
				tm1_n1 = 0;
			
			n1tm2 = tabtm2[0];
			
			for (j=0; j<2 ;j++)
				val2= n1tm1;	
			
				tabtm2[tm2_n1++] = val2;
				
			if(tm2_n1 == 1)
				tm2_n1 = 0;
	
	freqfiltre=(((d*n1tm1)-(b*n1tm2)+freq)/c);
	
	sprintf(txt,"%d;%llu;%llu;%llu\r\n",freq,n1tm1,n1tm2,freqfiltre);//%llu pour long long unsigned
	put_rs232(txt);
	
	// compteur utilisé pour le debug / pour la mise a jour de la temp
	if (cpt == 500)
	{
		cpt = 0;
		mesure_temp();
	}
	else
		cpt++;
			
	if(cpt2 == 16)
		cpt2 = 0;
	else
		cpt2++;
	
	switch (lecture_historique())
	{
		case CAL_NON_FAITE : 	
			K_value=0;
/*		
			value_p = value & 0xFFFF;
			value_n = (value & 0xFFFF0000) >> 16;
		
			if(value_p > value_n)
				value_n = 0;
			if(value_n > value_p)
				value_p = 0;							
			
			value = value_p - value_n;
*/
			value = mesure(ADC_CHAN_AV8) - 715;
			
			K_value = (K * value) / PRECISION_PID;
			I_value_temp = I_value;
			I_value_temp += ((value * I) / PRECISION_PID);
			
			n2 = VALUE_10MHz + I_value_temp + K_value;
			
			// Valeur min max de n2 (+/- 1Khz a 10mhz) 100ppm
			if(n2 > (VALUE_10MHz + 200000))
				n2 = (VALUE_10MHz + 200000);
			else if (n2 < (VALUE_10MHz - 200000))
				n2 = (VALUE_10MHz - 200000);
			else
				I_value = I_value_temp;
			
			// MODE test
			switch(test_active - 2)
			{
				case 0:
					sprintf(txt,"%d\r\n",n1);
					put_rs232(txt);
				break;
								
				case 1:
					sprintf(txt,"%d\r\n",n2);
					put_rs232(txt);
				break;				
				
				case 2:
					if (cpt2%2 == 0)
					{
						sprintf(txt,"%d;%d\r\n",n1,n2);
						put_rs232(txt);
					}
				break;
				
				case 3:
					sprintf(txt,"%d\r\n",value);
					put_rs232(txt);
				break;
				
				case 4:
					temp_n1 += n1;
					temp_n2 += (n2 - 1932900000);
					
					if (cpt2 == 0)
					{
						buffer_n1[indice_buffer_n1++] = temp_n1/16;
						if(indice_buffer_n1 == 16)
							indice_buffer_n1 = 0;
						sprintf(txt,"%d;%d;%d\n\r",temp_n1/16,temp_n2/16 + 1932900000, temp_n1/16 - buffer_n1[(indice_buffer_n1+1)%16]);
						put_rs232(txt);
						temp_n1 = 0;
						temp_n2 = 0;
					}
				break;
				
				case 5:
					if (cpt % 250 == 0)
						temp = -1000;
					else
					{
						if (cpt % 250 == 0)
							temp = 1000;
					}
				break;
				
				default:
					temp = 0;
				break;
			}

			setDDS10M(n2+temp);

			if(etape_temperature == 1 && premier_n1 == -1 && (n1 < n1_max || n1_max == 0))
				n1_max = n1;
				
			if(etape_temperature == 2 && (n1 > n1_min || n1_min == 0))
				n1_min = n1;
				
			if((n1 < (n1_min - MARGE_MAX_N1)) && (n1_min != 0) && etape_temperature == 2)
				etape_temperature = 3;
				
			if(etape_temperature == 1 && premier_n1 == -1 && (n1 > (n1_max + MARGE_MAX_N1)))
			{
				sprintf(txt,"premierN1=%d\n",n1);
				put_rs232(txt);
				premier_n1 = n1;
				nvmWrite32(REG_OFFSETN1, n1);
			}
			if((abs(value) < 50) && ((etape_temperature == 1) || (etape_temperature == 2))  && (n1 >= premier_n1) && (n1 < (premier_n1 + 65520)) && (premier_n1 != -1))
				ecrire(n1-premier_n1, n2);
			// decrochage pll
			if(abs(value) >= 50)
				gestion_led(7);
			else
			{
				if(etape_temperature == 0)
					gestion_led(2);
				else
					gestion_led(0);	
			}
		break;
		
		case CAL_FAITE_NON_FIT : 
		case CAL_FAITE_FIT :
			{
/*				
				temp_n1 += n1;
				
				if (cpt2 == 0)
				{
					buffer_n1[indice_buffer_n1++] = temp_n1/16;
					if(indice_buffer_n1 == 16)
						indice_buffer_n1 = 0;
	
					temp = temp_n1/16 - buffer_n1[indice_buffer_n1%16];
	
					temp_n1 = 0;
					temp_n2 = 0;
					
					sprintf(txt,"%d\r\n",temp * offsetN2);
					put_rs232(txt);
				}		
*/				
				if(premier_n1 == -1)
					premier_n1 = nvmRead32(REG_OFFSETN1);
	//			lit N2 ds nvm et sort sur DDS10MHz;
				freq=get_data_nvm(n1-premier_n1) + offsetN2 /*+ temp * offsetN2*/;
				//freqfiltre=(1/(1+(100*((2*z)/w0))+((1/(w0*w0)*10000)))*(((100*((2*z)/w0))+2*(10000*(1/(w0*w0)))*n1tm1)-((10000*(1/(w0*w0))*n1tm2)+(freq))));
				setDDS10M(freq);
			}
		break;
		
		default: 
//			put_rs232(" soft error");
			gestion_led(6);
		break;
	}
// Clear the interrupt within the timer.
	TMR_clear_int( &g_timer0 );
}

void init_var_isr()
{
	int val;
	
	val=nvmRead32(REG_OFFSET_10M);
	if(val != -1)
		offsetN2 = val;

	val=nvmRead32(REG_K);
	if(val != -1)
		K = val;
		
	val=nvmRead32(REG_I);
	if(val != -1)
		I = val;

//	val=nvmRead32(REG_OFFSETN1);
//	if(val != -1)
//		premier_n1 = val;
}

// "Digitaliseur" interrupt service routine.
//
/*

void n1_isr( void )
{
	char txt[30];
	static int n1old = 0;
	int n1_mes,n1_prec_mes,n1;
	
	lock_N1();
	n1_mes = read_gpio0();
	n1_prec_mes = read_gpio4();
	unlock_N1();
	
	if (n1_mes > n1_prec_mes)
		n1 = n1_mes - n1_prec_mes;
	else
		n1 = 262143 - n1_prec_mes + n1_mes ; // tour du compteur ((2^18) -1) = 262143
	
	sprintf(txt, "%d;", n1);
	
	put_rs232(txt);
	n1old = n1;
}

void n1_isr_old()
{
	static uint32_t valeur_compteur;
	static uint32_t n1_precedent;
	static int n1Prec=0;
	static int n1=0;
	static char refresh_n1;
	static int tau;
	static int pente;
	
	lock_N1();
	n1Prec = n1;
	valeur_compteur = read_gpio0();
	if (valeur_compteur>n1_precedent)
		n1 = valeur_compteur - n1_precedent;
	else // il y a eu rebouclage a zero
		n1=valeur_compteur+262143-n1_precedent;

	n1_precedent = valeur_compteur;
	pente=(n1-n1Prec)/(n1*1e-7)*tau;
	// reautorise l'irq
	unlock_N1();
	refresh_n1=1;
}		
*/

void uart_isr()
{
	// wake-up	
}