/**************************************************************************
 ***          Programme gestion roue a filtre par I2C / RS232           ***
 ***                                                                    ***
 **************************************************************************
 ***          Programmeurs: Laurent Bernasconi                          ***
 ***          Version : 1.0-2002                                        ***
 ***          Debut: 20/04/2003     Fin:                                ***
 **************************************************************************/

#include <16f873.h>

#fuses  HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT

#use delay(clock=20000000)
//#use I2C (slave, sda=PIN_C4, scl=PIN_C3, address=0x20)  //Adresse = 0x20!!
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)

#use fast_io(A)
#use fast_io(B)
#use fast_io(C)

#BIT    RCIF = 0x0C.5

#BIT    SSPIF = 0x0C.3
#BIT    PEIE = 0x0B.6
#BIT    BF = 0x94.0
#byte   SSPBUF = 0x13
#byte   SSPSTAT = 0x94
#byte   SSPCON = 0x14
#byte   SSPAD = 0x93
#byte   PIR1 = 0x0C
#BIT    P = 0x94.4
#BIT    WCOL = 0x14.7
#BIT    CKP = 0x14.4

#byte PORTA = 5
#byte PORTB = 6
#byte PORTC = 7


/****************************************************************
*                  Definition des Output                        *
****************************************************************/


#define ONEPHASE     PIN_A4  // Sequence 1 ou 2 phases alimenté
#define HALFSTEP     PIN_A3  // Mode pas ou demi pas
#define STEPINPUT    PIN_A2  // Horloge d'avancement moteur
#define DIRECTION    PIN_A1  // Selection du sens de rotation moteur
#define OUTENABLE    PIN_A0  // Validation de l'alimentation moteur


/****************************************************************
*                  Definition des Input                         *
****************************************************************/

//#define CAPTEURINDUC    PIN_B3
#define CAPTEURINDUC    PIN_C1

/****************************************************************
*                  Definition IEC                               *
****************************************************************/

// #define EEPROM_SDA  PIN_C4
// #define EEPROM_SCL  PIN_C3


/***************************************************************************
 ******         Definition des variables        ****************************
 ***************************************************************************/

/*
 * Variables globales
 *
 */

long 	CompteurPas; //Compteur de pas entre deux détections
int	NbFiltre;  // Nombre de filtres sur la roue a filtre
long  NbRefPasMax;   // valeur nominal du détecteur de position de depart: 1788
long  NbRefPasMin;
char	Ordre;
int	NumFiltre;
int	FutureNumFiltre;
int	Deplacement;
int	i;
int	EnCours;
int	Adresse;
//12340 pas pour un tour complet
//2468 pas entre deux filtres


/*************************************************************************************/
/********************************      Fonctions      ********************************/
/*************************************************************************************/

/****************************************************************
*       Function Name:  boot                                    *
*       Return Value:   void                                    *
*       Parametres:                                             *
*       Description:    Renvoie vers le code du booloader       *
****************************************************************/

#ORG 0x0F00,0x0FFF
RESERVE()
{
}


/****************************************************************
*       Function Name:  AvanceUnPas                             *
*       Return Value:                                           *
*       Parametres:     adresse de la variable                  *
*       Description:    Avance le moteur d'un pas               *
****************************************************************/

void AvanceUnPas()

{
	OUTPUT_HIGH(STEPINPUT);	//pin4
	delay_us(1000);
	OUTPUT_LOW(STEPINPUT);	//pin4
	delay_us(1000);
}


/****************************************************************
*       Function Name:  DetecteurSuivant                        *
*       Return Value:   CompteurPas  long                       *
*       Parametres:     adresse de la variable                  *
*       Description:    Déplace la roue sur le détecteur suivant*
****************************************************************/

void DetecteurSuivant()

{
	CompteurPas=0;
	while (input(CAPTEURINDUC))
	{
		AvanceUnPas();
		CompteurPas=CompteurPas+1;
        }
        while (!input(CAPTEURINDUC))
        {
        	AvanceUnPas();
        	CompteurPas=CompteurPas+1;
        }
}

/****************************************************************
*       Function Name:  InitRoue                                *
*       Return Value:   CompteurPas  long                       *
*       Parametres:     adresse de la variable                  *
*       Description:    Inicialisation de la roue               *
****************************************************************/

void InitRoue()

{
	// position de reference sur un premier détecteur
	printf ("Cherche...\n\r");
	DetecteurSuivant();
	printf ("Sur détecteur INIT\n\r");

	Delay_ms( 500 );

        // Cherche le filtre n°1
        DetecSuite1:
        DetecteurSuivant();
        printf ("Sur détecteur N°? (%ld) \n\r",CompteurPas);
        Delay_ms( 100 );
        if (compteurPas > NbRefPasMax)
        {
        	Goto DetecSuite1;
        }
        if (CompteurPas < NbRefPasMin)
        {
        	Goto Detecsuite1;
        }
        DetecteurSuivant();
        printf ("Sur détecteur N°1 (%ld) \n\r",CompteurPas);
        printf ("Filtre 1\n\r");

        Delay_ms( 500 );


        //Compte le nombre de Filtres
        NbFiltre=0;
        DetecSuite2:
        DetecteurSuivant();
        printf ("Sur détecteur N°? (%ld) \n\r",CompteurPas);
        NbFiltre=NbFiltre+1;
        if (compteurPas > NbRefPasMax)
        {
        	Goto DetecSuite2;
        }
        if (CompteurPas < NbRefPasMin)
        {
        	Goto Detecsuite2;
        }
        DetecteurSuivant();
        printf ("Sur détecteur N°1 (%ld) \n\r",CompteurPas);
        printf("Nombre Filtres: %c\n\r",NbFiltre+48);

	NumFiltre=1;
}

/****************************************************************
*       Function Name:  traite_Commande                         *
*       Return Value:   void                                    *
*       Parametres:                                             *
*       Description:    Traitement les commandes	        *
****************************************************************/
void traite_Commande()
{
printf("Traite Commande\n\r");
	if (Ordre==0x52)
		InitRoue();	// commande R = Reset de la roue

	else if (FutureNumFiltre > NumFiltre )
	{
		Deplacement=FutureNumFiltre-NumFiltre;
		printf("Déplacement : %D\n\r",Deplacement);
		for (i=0;i<Deplacement;i++)
		{
			DetecteurSuivant();
         printf ("Sur détecteur N°? (%ld) \n\r",CompteurPas);
			NumFiltre=NumFiltre+1;
		}
		printf("Sur Filtre :%c\n\r",NumFiltre+48);
	}

	else if (FutureNumFiltre < NumFiltre )
	{
		// Se replace sur le filtre 1
      printf("Se replace sur Filtre 1\n\r");
		DetecSuite3:
        	DetecteurSuivant();
         printf ("Sur détecteur N°? (%ld) \n\r",CompteurPas);
        	if (compteurPas > NbRefPasMax)
        	{
        		goto DetecSuite3;
        	}
        	if (CompteurPas < NbRefPasMin)
        	{
        		goto Detecsuite3;
        	}
        	DetecteurSuivant();
         printf ("Sur détecteur N°1 (%ld) \n\r",CompteurPas);
		NumFiltre=1;

		// Va sur le filtre désiré !
		printf("Déplacement : %D\n\r",FutureNumFiltre);
		for (i=1;i<FutureNumFiltre;i++)
		{
			DetecteurSuivant();
         printf ("Sur détecteur N°? (%ld) \n\r",CompteurPas);
			NumFiltre=NumFiltre+1;
		}
		printf("Sur Filtre :%c\n\r",NumFiltre+48);
	}
printf("Commande Traitée\n\r");
}


/**************************************************************************
 * Routine traitant les interruptions
 *
 * Lecture I2C
 *
 ***************************************************************************/

#int_SSP
void IntSSP()
{
	SSPIF=0;
	if (!BF)
		goto SortieIntSSP;
	Adresse=SSPBUF;				// Lit Adresse

 	while(!SSPIF);
 	SSPIF=0;
 	if (!BF)
		goto SortieIntSSP;
 	Ordre=SSPBUF;				// Lit Ordre

//	Ordre=getc();

 	if (Ordre==0x56)
 	{					// Commande V = Retourne la version du code
		while(!SSPIF);
 		SSPIF=0;
 		Adresse=SSPBUF;			// Lit Adresse

 		while(BF);
 		do
 		{
	 		WCOL=0;
 			SSPBUF=10;		//Ecrit Version 1.0
 		}
 		while (WCOL);
 		CKP=1;
	}

 	else if (Ordre==0x6E)
 	{					// Retourne le nombre de filtres au PC: commande: n
		while(!SSPIF);
 		SSPIF=0;
 		Adresse=SSPBUF;			// Lit Adresse

 		while(BF);
 		do
 		{
	 		WCOL=0;
 			SSPBUF=NbFiltre;		//Ecrit le nombre de filtre
 		}
 		while (WCOL);
 		CKP=1;
	}

	else if (Ordre==0x66)
	{					// Retourne le numero du filtre courant: f
		while(!SSPIF);
 		SSPIF=0;
 		Adresse=SSPBUF;			// Lit Adresse

 		while(BF);
 		do
 		{
	 		WCOL=0;
 			SSPBUF=NumFiltre;	//Ecrit le nombre de filtre
 		}
 		while (WCOL);
 		CKP=1;
	}

	else if ((EnCours==False) && (Ordre==0x52))
		EnCours=true;			// commande R = Reset de la roue

	else if (Ordre==0x45)			// commande E. Retourne l'etat de la roue.
	{
		while(!SSPIF);
 		SSPIF=0;
 		Adresse=SSPBUF;			// Lit Adresse

		while(BF);
 		do
 		{
	 		WCOL=0;
 			SSPBUF=(EnCours);	// Ecrit drapeau d'etat de la roue.
 		}
 		while (WCOL);
 		CKP=1;
	}

 	else if ((EnCours==False) && (Ordre>0) && (Ordre<(1+NbFiltre)))
	{					// Commande des filtres: 1, 2, 3, 4....
		#asm
        		MOVF   Ordre,W
                	MOVWF  FutureNumFiltre
        	#endasm

		FutureNumFiltre=FutureNumFiltre-48;

		if (FutureNumFiltre > NumFiltre)
		{
			EnCours=true;
		}

		else if (FutureNumFiltre < NumFiltre)
		{
			EnCours=true;
		}
 	}

 SortieIntSSP:
	PIR1=0;
	SSPCON=0x36; 	//I2C Esclave Adresse 7 Bits SCL Fonctionne
	SSPAD=0x20;	// Adresse = 0x20!
	SSPSTAT=0;
}


/*************************************************************************************/
/******************************** Programme principal ********************************/
/*************************************************************************************/

main()
{


	SETUP_ADC_PORTS(NO_ANALOGS);

        SET_TRIS_A(0x00);           // Pins du PORTA en output
        SET_TRIS_B(0xFF);           // Pins du PORTB en input
        SET_TRIS_C(0xFF);           // PORTC en input

	PORT_B_PULLUPS(TRUE);

	OUTPUT_HIGH(ONEPHASE);	//2
	OUTPUT_LOW(HALFSTEP);	//3 sequence une phase alimenté

	OUTPUT_LOW(STEPINPUT);  //4
	OUTPUT_LOW(DIRECTION);	//5 sens de base= 0
	OUTPUT_LOW(OUTENABLE);	//6 Valide l'alimentation du moteur

        //init_I2C()
//	PIR1=0;
//	SSPCON=0x36; 	//I2C Esclave Adresse 7 Bits SCL Fonctionne
//	SSPAD=0x10;	// Adresse = 0x10!
//	SSPSTAT=0;

 	NbRefPasMax=300;   // valeur nominal du détecteur de position de depart: 1788
	NbRefPasMin=200;

	//12340 pas pour un tour complet
	//2468 pas entre deux filtres

 	Delay_ms( 500 );

   NbFiltre=5;
	NumFiltre=1;

//	InitRoue();  // pas pour le moment

        //Coupe Alimentation Moteur
        OUTPUT_HIGH(OUTENABLE);	//6

	//RCIF=0;

//	enable_interrupts(int_SSP);
//	enable_interrupts(global);
        PEIE=1;			// BUG dans le compilateur!!!! Valide Int des Périfériques du PIC!
        EnCours=false;


 	while (true)
   {

	Ordre=getc();

 	if (Ordre==0x56)
 	{					// Commande V = Retourne la version du code
		printf("Version V1.1-RS232\n\r");
		printf("SARL mécASTROnic c2006\n\r");
	}

 	else if (Ordre==0x6E)
 	{					// Retourne le nombre de filtres au PC: commande: n
		printf("Nombre de Filtres : %D\n\r",NbFiltre);
	}

	else if (Ordre==0x66)
	{					// Retourne le numero du filtre courant: f
		printf("Numéro du Filtre : %D\n\r",NumFiltre);
	}

	else if ((EnCours==False) && (Ordre==0x52))
		EnCours=true;			// commande R = Reset de la roue

	else if (Ordre==0x45)			// commande E. Retourne l'etat de la roue.
	{
      if (Encours)
   		printf("TRUE\n\r");
      else
   		printf("FALSE\n\r");
	}

 	else if ((EnCours==False) && (Ordre>48) && (Ordre<(49+NbFiltre)))
	{					// Commande des filtres: 1, 2, 3, 4....
		#asm
         MOVF   Ordre,W
         MOVWF  FutureNumFiltre
      #endasm

		FutureNumFiltre=FutureNumFiltre-48;
		printf("Filtre demandé : %D\n\r",FutureNumFiltre);

		if (FutureNumFiltre > NumFiltre)
		{
			EnCours=true;
		}

		else if (FutureNumFiltre < NumFiltre)
		{
			EnCours=true;
		}
 	}

   if (EnCours)
   {
      OUTPUT_LOW(OUTENABLE);	//6 Valide l'alimentation du moteur
      traite_Commande();
      EnCours=false;
      Delay_ms( 500 );
      OUTPUT_HIGH(OUTENABLE);	//6 Coupe Alim. Moteur
   }

 	}



// 	while (true)
//        {
//        	if (EnCours)
//        	{
//        		OUTPUT_LOW(OUTENABLE);	//6 Valide l'alimentation du moteur
//                 	traite_Commande();
//                 	EnCours=false;
//                 	Delay_ms( 500 );
//                 	OUTPUT_HIGH(OUTENABLE);	//6 Coupe Alim. Moteur
//                 }
// 	}
}