//-----------------------------------------------------------------------------------//
// Nom du projet 		:	Coursera_Microcontroleur
// Nom du fichier 		:   main_3_7.c
// Date de création 	:   18.04.2014
// Date de modification : 	18.06.2014
// 
// Auteur 				: 	Philou (Ph. Bovey) 
//
// Description 			:   dans un tableau (avec 8 emplacement), celui-ci sera 
//							rempli de manière alétaoire, chercher la valeur la plus
//							grande, pour indiquer l'emplacement une led correspondant 
//							a la case mémoire clignotera, lorsque l'on appuiera sur 
//							une touche
// Remarques			: 
// 	    chemin pour trouver le headerfile 
//		C:\Program Files\Microchip\MPLAB C30\support\dsPIC33F\h
//
//	    lien utile : 
//      1) pseudo-Aléatoire 
//		http://fr.openclassrooms.com/informatique/cours/l-aleatoire-en-c-et-c-se-servir-de-rand-1
//
//----------------------------------------------------------------------------------//
//--- librairie à inclure ---// 
#if defined(__dsPIC33F__)
#include "p33Fxxxx.h"
#endif

//--- autres librairires ---// 
#include "antirebond.h"
#include <string.h>
#include <stdlib.h>

//--- Fusibles ---//	
_FOSCSEL(FNOSC_PRI); 								// utilisation du quartz de 8MHz externe 
_FOSC(FCKSM_CSECMD & OSCIOFNC_OFF  & POSCMD_XT); 	// pin OS2 garder pour l'horlohe 
													// oscillateur XT	
_FWDT(FWDTEN_OFF); 									// ne pas activer le watchdog

//--- definition ---//
#define TAILLE_TB	8								// valeur 
#define ALLUME_XX	0xFF 

#define SWITCH 		PORTDbits.RD6					// entrée  
#define LEDS 		LATA							// sortie 

//--- déclaration de prototypes ---// 
char recherche_max(char *pt_tb);  					// permet de chercher une valeur max dans un tb
void init_oscillateur(void); 						// configuration oscillateur 
void init_in_out(void);								// configuration entree - sortie  
void init_timer1(void); 							// configuration Timer1   
void activ_leds(int cmpt);							// permet de faire allumer une led 
void remplissage_hazard(char *pt_tb, char cmpt);  	// permet de remplir un tableau de 8 caractères 
void affichage_position(char position); 

//--- déclaration de variables gloables ---//
Etat_switch pt_switch_s3; 

int grand_compteur; 
				
//--- programme principale ---//
int main(void)
{
	//--- déclaration de variables ---// 
	char compteur = 0;
	char position; 
	char tb_led[TAILLE_TB] = {23, 43, 66, 51, 11, 63, 0, 0}; 

	//--- initialisation ---//
	init_oscillateur(); 				// oscillateur
	init_timer1(); 						// Timer 1 
	init_in_out(); 						// IN/OUT     
	
	//--- boucle sans fin ---//
	while(1)
	{
		//--- si touche pressee --> renouvelement du tebbleau ---//  
		if(switch_presser(&pt_switch_s3))
		{
			remplissage_hazard(tb_led, compteur);
			reset_info_touche_presser(&pt_switch_s3); 			
		} 
	 
		//--- appel de la fonction pour rechercher un max dans un tableau ---// 
		position = recherche_max(tb_led); 

		//--- appel d'une fonction d'affichage ---// 
		affichage_position(position); 

		//--- compteur pour valeur alétaoire ---//
		compteur++; 
		if(compteur >= 255)
			compteur = 0;  	    
	}   
}

//----------------------------------------------------------------------------------//
//--- nom 				: init_in_out
//--- entrée - sortie 	: - / - 
//--- description 		: initialisation IN/OUT ANAL/NUM --> 
//--- remarque 			: doc = section 10 
//----------------------------------------------------------------------------------//
void init_in_out(void)
{	
	//--- configuration entrée analogique ---// 

	//--- configuration entrée numérique ---//
	TRISDbits.TRISD6 = 1; 						//--> SWI3 
 	
	//--- configuration sortie numérique ---//
	TRISA = 0x00; 								// 8 bits sur le port A  
}

//----------------------------------------------------------------------------------//
//--- nom 				: init_oscillateur
//--- entrée - sortie 	: - / - 
//--- description 		: configuration oscillateur | clock à choix  
//-- remarque 			: doc = section 7
//----------------------------------------------------------------------------------//
void init_oscillateur(void)
{
	//--- configuration de l'oscillateur interne à 8Mhz ---//
	// utilisation formules du datasheet du DSPic33FJ256GP710A --> page 146
	// quartz utilisé sur le carte = 8MHz = Fin
	// Fcy = Fosc / 2 ; Fosc = Fin(M/(N1 N2))
	// Fin = 8Mhz --> Fosc = 16Mhz --> Fcy = 8Mhz 
	OSCCONbits.COSC 	= 3;			// sélection de l'oscillateur XT 
	OSCCONbits.CLKLOCK	= 0;			// l'horloge et la PLL peuvent être modifié 	
	
	CLKDIVbits.ROI	= 0; 				// pas d'effet si il y a interruption 
	CLKDIVbits.DOZE	= 0; 				// pas de réduction sur l'horloge Fcy /1
	CLKDIVbits.DOZEN	= 0; 		
	CLKDIVbits.PLLPRE 	= 0; 			// N1 = 2	
    CLKDIVbits.PLLPOST 	= 0; 			// N2 = 2 	
	
	PLLFBDbits.PLLDIV 	= 6;			// M = 8  

	__builtin_write_OSCCONH(0x03); 		// fonction appelant du code assembleur 
										// configuration du registre NOSC (OSCCON) --> 
										// 011 = Primary Oscillator with PLL (XTPLL, HSPLL, ECPLL)
	__builtin_write_OSCCONL(0x01);		// Active la commutation de la clock
	while(OSCCONbits.COSC != 0b011); 	//
}

//----------------------------------------------------------------------------------//
//--- nom 				: init_timer1
//--- entrée - sortie 	: - / - 
//--- description 		: initialisation timer 1 pour avoir une horloge de 50ms
//--- remarque 			: doc = section 11 
//----------------------------------------------------------------------------------//
void init_timer1(void)
{
	//--- registre de configuration du Timer1 ---//
	T1CONbits.TON = 0; 			// désactiver le timer pour la configuration 
	T1CONbits.TCS = 0; 			// clock interne
	T1CONbits.TSYNC = 0; 		// synchroniser la clock externe 	
	T1CONbits.TCKPS = 3; 		// prédivseur régler à 256 --> 8Mhz/256 = 31250Hz --> 32us 
	
	TMR1 = 0; 					// mise à zéro du registre lié au timer 

	PR1 = 1562; 				// période du timer --> 50ms/32us = 1562.5 

	//--- registres des configurations des interruptions liées au Timer1 ---//
	IPC0bits.T1IP = 7; 			// choix de la priorité --> ici la plus élevée 7 = 111
	IFS0bits.T1IF = 0; 			// remise à zéro de l'interruption 
	IEC0bits.T1IE = 1; 			// activation de l'interruption lié au Timer1 

	T1CONbits.TON = 1; 	    	// désactiver le timer1 au démarrage
}

//----------------------------------------------------------------------------------//
//--- nom 				: _T1Interrupt
//--- entrée - sortie 	: - / - 
//--- description 		: interruption liée au  
//----------------------------------------------------------------------------------//
void __attribute__((interrupt,no_auto_psv)) _T1Interrupt( void )
{
	//---  ---//
	IFS0bits.T1IF = 0; 			// remise à zéor du flag d'interruption
	
	//--- lecture de la touche S3 ---//
	antirebond(&pt_switch_s3, SWITCH);

	//--- incrémentation compteur ---//
	grand_compteur++; 		
	if (grand_compteur >= 65535) 
		grand_compteur = 0; 
	
	TMR1 = 0; 				// mise à jour du registre de comptage 
	T1CONbits.TON = 1;		// activer à nouveau le Timer */ 
}

//----------------------------------------------------------------------------------//
//--- nom 				: recherche_max
//--- entrée - sortie 	: - / pos_case / *pt_tb 
//--- description 		: on pointe sur tableau ou l'on recherche la valeur la plus 
//						  grande, on renvoit la position de la case.   
//--- remarque 			:   
//----------------------------------------------------------------------------------//
char recherche_max(char *pt_tb)
{
	//--- déclaration de variables ---// 
	char pos_case;
	char taille_tb;
	char i; 
	char val_max = 0;   

	//--- connaître la longueur du tableau ---//
	taille_tb = strlen(pt_tb); 

	//--- parcourir le tableau ---// 
	for(i = 0; i < taille_tb; i++)
	{
		//--- test si la valeur  ---//
		if(val_max < pt_tb[i])
		{
			val_max = pt_tb[i];	// enregistrement de la valeur plus grande 
			pos_case = i + 1;	// enregistrement de la position 	
		}  
	}
	return pos_case;  
}


//----------------------------------------------------------------------------------//
//--- nom 				: recherche_max
//--- entrée - sortie 	: - / pos_case / *pt_tb 
//--- description 		: on pointe sur tableau ou l'on recherche la valeur la plus 
//						  grande, on renvoit la position de la case.   
//--- remarque 			: voir le lien 1) 
//----------------------------------------------------------------------------------//
void remplissage_hazard(char *pt_tb, char cmpt)
{
	//--- déclaration de varibales interne ---// 
	int recup_alea = 0; 
	int limit_inf = 0; 
	int limit_sup = 256; 
	char i; 

	//--- remplissage du tableau ---//
	for(i = 0; i < TAILLE_TB; i++)
	{	
		srand(i+(grand_compteur/(int)cmpt)*recup_alea);
		recup_alea = rand() % (limit_sup - limit_inf) + limit_inf;
		pt_tb[i] = (char)recup_alea;   
	} 
}

//----------------------------------------------------------------------------------//
//--- nom 				: affichage_position
//--- entrée - sortie 	: position / - / -  
//--- description 		: on reçoit une position et cela va allumé la led qui 
//						  correspond à celle-ci 
//--- remarque 			:   
//----------------------------------------------------------------------------------//
void affichage_position(char position)
{
	switch (position)
	{	
		case 1:
			LATA = ALLUME_XX & 0X01; 
		break;

		case 2:
			LATA = ALLUME_XX & 0X02; 
		break;

		case 3:
			LATA = ALLUME_XX & 0X04;
		break;

		case 4:
			LATA = ALLUME_XX & 0X08;
		break;

		case 5:
			LATA = ALLUME_XX & 0X10;
		break;

		case 6:
			LATA = ALLUME_XX & 0X20;
		break;

		case 7:
			LATA = ALLUME_XX & 0X40;
		break;

		case 8:
			LATA = ALLUME_XX & 0X80;
		break;

		default:
			LATA = ALLUME_XX; 
		break; 
	}	
}