#define ICD2_DEBUG

//Déclarations de Variables
//const char val_min[12] = {89, 98, 106, 115, 125, 136, 147, 159, 172, 184, 199}; // plages minimales
//const char val_max[12] = {92, 101, 109, 119, 129, 139, 150, 162, 176, 189, 203}; // plages maximales
const char val_min[12] = {87, 96, 104, 113, 123, 134, 142, 157, 170, 182, 197}; // plages minimales
const char val_max[12] = {94, 103, 111, 121, 131, 141, 156, 164, 178, 191, 205}; // plages maximales
const char val[12] = {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'R'}; // valeurs correspondantes a chaque plages

char tab[5]; // contenu des 5 valeur correpondant au code 5 tons
char adresse[5]; // contenu de l'adresse du relai

char enr_lec, voc_mil, test, mess1_mess2;

void tempo(char ti); // fonction de "pause"
char CAN(void); // renvoie la valeur du convertisseur
char lire_valeur(char i); // Permet de lire les 5 valeurs à suivre pour une fréquence
char verif_can(char can); // permet de vérifier si la valeur du CAN est bien comprise dans une des plages
void milleHcont(void); // permet de générer le 1000Hz continu
void milleHdiscont(void); // permet de générer le 1000Hz dicontinu
void ordon_tab(void); // permet de changer les R du code 5 tons en la valeur précédente dans le tableau

void tempo(char ti) // fonction de "pause"
{
	INTCON.2 = 0;
	TMR0 = ti;
	while(INTCON.2 == 0);
}

char CAN(void) // renvoie la valeur du convertisseur sur AN1
{
	char ta, cnt;
	ADCON1 = 0x00;
	ta = TRISA;
	TRISA = TRISA | 0x2F;
	ADCON0 = 0x81 | (1 << 3);
	cnt =0;
	for (cnt=0;cnt<=220;cnt++);
	ADCON0 = ADCON0 | 0x04;
	while (ADCON0 & 0x04);
	TRISA = ta;
	ADCON1 = 0x07;
	return ADRESH;
}

/*

*/

/**********************************************************************************
* Cette fonction permet de faire les 5 mesures pour chaque codes du code 5 tons
***********************************************************************************
* Entrées :
*	i : indice du tableau auquel correspond le code 5 ton
***********************************************************************************
* Sorties :
*	Renvoie 1 si les 5 valeurs sont identiques et correspondent à une de plages, renvoie 0 autrement
***********************************************************************************
*Fonction Lire_Valeur
*	Attendre 10ms
*	A = Lire CAN et lancer la fonction verif_CAN (ci-dessous) pour vérifier cette valeur)
*	Attendre 10ms
*	B = Lire CAN et lancer la fonction verif_CAN (ci-dessous) pour vérifier cette valeur)
*	Si (A = B)
*		Attendre 10ms
*		B = Lire CAN et lancer la fonction verif_CAN (ci-dessous) pour vérifier cette valeur)
*		Si (A = B)
*			Attendre 10ms
*			B = Lire CAN et lancer la fonction verif_CAN (ci-dessous) pour vérifier cette valeur)
*			Si (A=B)
*				Attendre 10ms
*				B = Lire CAN et lancer la fonction verif_CAN (ci-dessous) pour vérifier cette valeur)
*				Si (A=B)
*					Mettre A dans le tableau contenant les codes du code 5 tons
*				Sinon Arrêter FinSi
*			Sinon Arrêter FinSi
*		Sinon Arrêter FinSi
*	Sinon Arrêter FinSi
*FinFonction
***********************************************************************************/

char lire_valeur(char i) // Permet de lire les 5 valeurs à suivre pour une fréquence
{
	char b, ret, can;
	char tab2[5]; // Contenu des 5 mesures faites à la suite pour mesurer une fréquence.
	PORTB = PORTB^0xFF;
	//tempo(181); // tempo de 20ms
	tempo(220);
	can = CAN();
	tab2[0] = verif_can(can);
	b = val_min[0];
	if ((can >= b))
	{
		PORTB = PORTB^0xFF;
		tempo(220);
		tab2[1] = verif_can(CAN());
		if (tab2[0] == tab2[1])
		{
			PORTB = PORTB^0xFF;
			tempo(220);
			tab2[2] = verif_can(CAN());
			if (tab2[0] == tab2[2])
			{
				PORTB = PORTB^0xFF;
				tempo(220);
				tab2[3] = verif_can(CAN());
				if (tab2[0] == tab2[3])
				{
					PORTB = PORTB^0xFF;
					tempo(220);
					tab2[4] = verif_can(CAN());
					if (tab2[0] == tab2[4])
					{
						PORTB = PORTB^0xFF;
						tab[i] = tab2[0];
						ret = 1;
						tempo(100);
					} else { ret = 0; }
				} else { ret = 0; }
			} else { ret = 0; }
		} else { ret = 0; }
	} else { ret = 0; }

	return ret;
}

/**********************************************************************************
* Cette fonction permet retourner la valeur correspondant à la plage de fréquence.
***********************************************************************************
* Entrées :
*	can : Correspond à la valeur mesurée par le CAN
***********************************************************************************
* Sorties :
*	Renvoie la valeur correspond au code 5 ton correspondant, ou 0 si aucun code ne correpond
***********************************************************************************
*Fonction verif_CAN
*	i = 0
*	ret = 0
*	faire
*	TantQue ret = 0 et i<10 // <10 car il n'y a que 11 valeurs possibles pour le code 5 tons
*		Si can < val_min[i] ou can > val_max[i] // val_min et val_max correspondent a la plage de fréquence correpondant à chaque code
*			on laisse ret à 0
*		Sinon
*			ret = val[i] // val correpond au tableau correspondant aux code 5 tons
*		FinSi
*		Incrémenter i
*	FinTantQue
*	Retourner ret
*FinFonction
***********************************************************************************/

char verif_can(char can)
{
	char i, ret, min, max;
	i = 0;
	ret = 0;
	do
	{
		min = val_min[i];
		max = val_max[i];
		if ((can<min) || (can>max))
		{
			ret = 0;
		} else {
			ret = val[i];	
		}
		i++;
	} while ((ret==0) && (i<=10));
	return ret;
}

void milleHcont(void) // permet de générer le 1000Hz continu
{
	char i;
	TRISC = TRISC&0xFB;
	for (i=0;i<=100;i++) // pour faire le 1000Hz continu pendant environ 5s
	{
		tempo(0);
	}
	TRISC = TRISC|0x04;
}

void milleHdiscont(void) // permet de générer le 1000Hz dicontinu
{
	char i;
	for (i=0;i<=50;i++) // pour faire le 1000Hz discontinu pendant environ 5s
	{
		TRISC = TRISC&0xFB;
		tempo(0);
		TRISC = TRISC|0x04;
		tempo(0);
	}
	TRISC = 0xFF;
}

/**********************************************************************************
* Cette fonction permet de changer les R du code 5 tons par les valeurs précédente du tableau
***********************************************************************************
*Fonction ordon_tab
*	Pour chaque valaur du tableau contenant le code 5 ton faire
*		Si la valeur = R alors
*			Remplacer le R par la valeur de la case précédente du tableau
*		FinSi
*	FinPour
*FinFonction
***********************************************************************************/

void ordon_tab(void) // permet de changer les R du code 5 tons en la valeur précédente dans le tableau
{
	char i, a;
	for (i=1;i<=4;i++)
	{
		if (tab[i] == 'R')
		{
			a = tab[i-1];
			tab[i] = a;
		}
	}
}

/**********************************************************************************
* Cette fonction permet de vérifier que le code 5 tons correspond bien au code du relais défini par l'utilisateur
***********************************************************************************
* Sorties :
*	Renvoie 1 si les codes mesurés sont identique à ceux défini par l'utilisateur, 0 sinon
***********************************************************************************
*Fonction verif_tab
*	ret = 1
*	Pour chaque valeur du tableau contenant le code 5 ton faire
*		Si (la valeur de la case actuelle du tableau = le code du relais définie par l'ATR) et ret = 1
*			ret = 1
*		Sinon
*			ret = 0
*		FinSi
*	FinPour
*	Retourner ret
*FinFonction
***********************************************************************************/

char verif_tab(void)
{
	char i, ret, a, b;
	ret = 1;
	for (i=0;i<=4;i++)
	{
		a = tab[i];
		b = adresse[i];
		if ((ret == 1) && (a == b))
		{
			ret = 1;
		} else {
			ret = 0;
		}
	}
	return ret;
}

/**********************************************************************************
* Cette fonction permet de changer les R du code 5 tons par les valeurs précédente du tableau
***********************************************************************************
* Entrées :
*	i : correspond à la case correspondant 
*	adr : correspond à l'adresse lu sur le Switch
***********************************************************************************
*Fonction lire_adresse
*	Selon adr
*		0 : mettre adresse[i] à '0'
*		1 : mettre adresse[i] à '1'
*		2 : mettre adresse[i] à '2'
*		3 : mettre adresse[i] à '3'
*		4 : mettre adresse[i] à '4'
*		5 : mettre adresse[i] à '5'
*		6 : mettre adresse[i] à '6'
*		7 : mettre adresse[i] à '7'
*		8 : mettre adresse[i] à '8'
*		9 : mettre adresse[i] à '9'
*	FinSelon
*FinFonction
***********************************************************************************/

void lire_adresse(char i,char adr)
{
	switch (adr)
	{
		case 0: adresse[i] = '0';
		case 1: adresse[i] = '1';
		case 2: adresse[i] = '2';
		case 3: adresse[i] = '3';
		case 4: adresse[i] = '4';
		case 5: adresse[i] = '5';
		case 6: adresse[i] = '6';
		case 7: adresse[i] = '7';
		case 8: adresse[i] = '8';
		case 9: adresse[i] = '9';
	}
}

/**********************************************************************************
* Cette fonction permet de lire les 2 premiers codes définies par l'utilisateur grace aux switchs
***********************************************************************************
*Fonction init
*	Définir le CAN actif sur RA1
*	Configurer la temporisation
*	Mettre les bits 0 à 3 du PORTB en entrées et les bits 4 à 7 en sorties
*	Mettre les bits 0,1,5,6,7 du PORTA en entrées et les bits 2,3,4 en sorties
*	Mettre le PORTA à 0xFF
*	Lire le 1er code de l'adresse du relais
*	Lire le 2nd code de l'adresse du relais
*FinFonction
***********************************************************************************/

void init(void)
{
	char adr;

	ADCON1 = 0x07; // défini sur quel bit on va faire la CAN

	OPTION_REG = 0xC7; //défini la temporisation

	TRISB = 0x0F; // bits 0 à 3 : entrées; bits 4 à 7 : sorties
	TRISA = 0xE3; // bits 0,1,5,6,7 : entrées; bits 2,3,4 : sorties
	PORTA = 0xFF;

	// lecture du 1er chiffre de l'adresse du relais
	PORTA.2 = 0;
	adr = PORTA;
	lire_adresse(0, adr);
	PORTA.2 = 1;
	
	// lecture du 2nd chiffre de l'adresse du relais
	PORTA.3 = 0;
	adr = PORTA;
	PORTA.3 = 1;
	lire_adresse(1, adr);
}

void main(void)
{
	char in, A;

	do
	{
		do 
		{
			A = verif_can(CAN());
		} while (A == 0);

		in = 0;
		do
		{
			A = lire_valeur(in);
			in++;
			if (A == 0) { in = 0; }
		} while ((in<=4) && (A !=0));

		if (in == 5)
		{
			ordon_tab(); // permet de changer les R du code 5 tons en la valeur précédente dans le tableau
			A = verif_tab(); // permet de vérifier si les valeurs du code 5 tons sont bien identique à l'adresse du relais
		}

	}
	while(1);
}