====== Exercice 1 ======
===== Sujet: =====

**Sélection de commande du moteur E.G.**
==== Objectifs : ====
  * Définir les différentes trames interrogatives ou de commande à faire transiter par le réseau CAN en fonction d'une action souhaitée.
  * Adapter le commande d'un actionneur électrique (moteur à courant continu) par réseau CAN, en fonction de l'état de signaux d'entrées (binaires et analogique) accessibles par réseau CAN, afin de satisfaire un cahier des charges imposé.

==== Cahier des charges : ====
L'état de fonctionnement du moteur "Essuie Glace" dépend de l'état du commodo Essuie Glace avec le cahier des charges suivant:
  * Si Pos1 (GP4) actionné, le moteur tourne à petite vitesse fixe.
  * Si Pos2 (GP5) actionné, le moteur tourne à grande vitesse fixe.
  * Si Pos3 (GP6) actionné, le moteur tourne à vitesse ajustable imposée par l'entrée analogique AN0 du module Commodo E.G.,
  * Si Pos4 (GP7) actionné, le moteur a un fonctionnement marche/arrêt cyclique avec, dans l'état "marche", une vitesse ajustable imposée par l'entrée analogique AN0.
{{  :fr:exercises:can:wiper:gp7.png  |}}

  * Si ni Pos1 (GP4), ni Pos2 (GP5), ni Pos3 (GP5) est actionné, le moteur reste à l'arrêt

===== Informations utiles =====
==== Acquisition des entrées "Commodo Essuie Glace" ====

La technique d'acquisition des entrées binaires et de l'entrée analogique, par réseau CAN, du module "Commodo E.G" est décrite dans le TP exemple n°1.

==== Commande du moteur Essuie Glace ====

La technique de commande du moteur Essuie Glace est décrite dans le TP exemple n°2.

==== Déclaration et utilisation de variables binaires ====

Si on souhaite déclarer des variables binaires, il est possible d'utiliser la structure de données de type "union" de label "byte_bits" déclarée dans le fichier "Structures_Données.h"

<code c>
/* 	Union pour accéder à un octet (BYTE) soit en direct, soit en individualisant les 8 bits 
//**********************************************************************************************/
	union byte_bits
	{	struct 
		 {	unsigned char b7:1;
			unsigned char b6:1;
			unsigned char b5:1;
			unsigned char b4:1;
			unsigned char b3:1;
			unsigned char b2:1;
			unsigned char b1:1;
			unsigned char b0:1;
		}bit;
		BYTE valeur;
	};
</code>

**Utilisation:**

  * Dans la partie déclarative du programme

<code c>
/* Déclaration des variables*/
// Pour les variables binaires 
union byte_bits Indicateurs; // Structures de bits
#define User_Bit1 Indicateurs.bit.b0  //  déclaration variable binaire
#define User_Bit2 Indicateurs.bit.b1  // 
</code>

  * Utilisation des variables binaires dans les fonctions

<code c>
// Pour initialiser tous les 8 bits de l'ensemble "Indicateurs"
Indicateurs.valeur=0x00;  // tous les bits sont initialisés à 0
// Pour affecter une valeur à une variable binaire 
User_Bit1=1; 
User_Bit0=0;
// Pour tester la valeur d'une variable binaire 
if(User_Bit1==1)    // Autre solution  "if(User_Bit1)"   car vrai si ≠ 0
	{ // Actions à faire si valeur = 1
	  …
	}
else 	{ // Actions à faire si valeur = 0
	  …
	}
if(User_Bit2==0)    	
	{ // Actions à faire si valeur = 0
	  …
	}
</code>

==== Réalisation d'une base de temps ====

Le micro contrôleur implanté sur la carte processeur EID210 intégre un bloc fonctionnel (noté ''Time Processor Unit  (TPU)'' permettant la réalisation de fonctions temporelles.
L'une des nombreuses fonctions du TPU est la génération d'une interruption périodique.
Exemple d'application: 
Soit la génération d'une temporisation égale à 1 S, comme le montre les signaux ci-desous.

{{  :fr:exercises:can:wiper:signaux.png  |}}

**Solution:**
Si on envisage une base de temps élémentaire égale à 1mS, la solution comportera les parties de programmes suivantes:

  * Dans la partie déclarative du programme

<code c>
/* Déclaration des variables*/
// Pour les variables binaires 
union byte_bits Indicateurs; // Structures de bits
#define Demande_Tempo Indicateurs.bit.b0  //  déclaration variables 
#define Reponse_Tempo Indicateurs.bit.b1  //  pour temporisation
#define Tempo_En_Cours Indicateurs.bit.b2
// Pour le compteur de passage dans la fonction d'interruption
int CPTR_mS;	/* déclaration des variables et compteurs de millisecondes */
</code>	
 
  * Définition de la fonction d'interruption

<code c>
/* FONCTION d'interruption pour temporisation  (base de temps: toutes les 10 mS)
=============================================================================*/
void irq_bt()   
{
	 if (Tempo_En_Cours==1)
		{ CPTR_mS++;
                 if(CPTR_mS ==100) Reponse_Tempo=1,Tempo_En_Cours=0,CPTR_mS=0;
		}
} // Fin de la définition de la fonction d'interruption pour la temporisation
</code>

  * Définition partielle de la fonction principale

<code c>
/*==============================*/
/*      Fonction principale     */
/*==============================*/
main()
{
/*   Initialisations *
*********************/
// Pour base de temps
SetVect(96,&irq_bt);	     	// mise en place de l'autovecteur 
PITR = 0x0048;			// Une interruption toutes les 10 millisecondes 
PICR = 0x0760; 		//  96 = 60H
// Pour la temporisation
CPTR_mS=0;			// initialisation compteurs millisecondes
Demande_Tempo=0;
Reponse_Tempo=0;
Tempo_En_Cours=0;
/* Boucle principale *
**********************/    
	do
	{  // A l'endroit où l'on souhaite démarrer la tempo
		Demande_Tempo=1;
		Tempo_En_Cours=1;
	   // … Pour tester si fin tempo
	   if(Reponse_Tempo==1)
		{ Reponse_Tempo=0;
		  // Actions à faire à la fin de la temporisation
			…
		}
	   // Pour réinitialisation
		Demande_Tempo=0;
		…
		if(Demande_Tempo==0)Reponse_Tempo=0,Tempo_En_Cours=0,CPTR_mS=0;
 
    	}while(1);  	/*  Fin de la boucle principale */
} /* Fin de la fonction principale */
</code>