Exemple 2 (TP2)

Marche/arrêt du moteur de l'essuie-glace.

• Définir les différentes trames de commande à faire transiter par le réseau CAN en fonction d'une action souhaitée.

• Commander un actionneur électrique (moteur à courant continu) en variation de vitesse, par l'intermédaire d'un pré-actionneur commandable par réseau CAN.

Le bouton poussoir BP1, connecté sur l'entrée GP4 du “CAN Expander” sur module 8 entrées sur lequel peut être connecté le commodo Essuie-Glace, est utilisé pour commander le moteur:

• BP1 appuyé (GP4 = 0) → le moteur est en marche
• BP1 n'est pas appuyé (GP4 = 1) → le moteur est à l'arrêt

La vitesse du moteur est définie par l'entrée analogique n°0 du module “Commodo Essuie Glace”.

Principe: Le module “Asservissement” (dont on donne le schéma structurel en Annexe) permet la commande d'un moteur à courant continu 12V/ 1A, dans les deux sens de rotation, en mode “PWM” (modulation de largeur d'impulsions). Un circuit de puissance (réf: L6202“), pilotable par signaux logiques est implanté sur le module. D'après le schéma électronique du module “Asservissement” donné en Annexe, ce pilotage se fait par les sorties GP2, GP3 et GP4 de l'interface CAN (circuit MCP25050):

• GP2 ou PWM1 sortie logique à rapport cyclique variable, qui permet de faire varier la vitesse
• GP3 ou PWM2 sortie logique à rapport cyclique variable, qui permet de faire varier la vitesse du moteur dans le sens négatif,
• GP4 ou ValidIP sortie logique qui, lorqu'elle est positionnée à 1, Valide le circuit d' Interface de Puissance “L6202”.

Dans notre application, on fera tourner le moteur en positif. Seule la sortie PWM1 sera activée. Par contre la sortie GP4 ou ValidIP devra être positionnée à 1.

Définitions des trames pour commander le moteur: Une sucession de trames de commande (type IM) devra être envoyée, dans un ordre bien précis au module asservissement, afin de l'initialiser dans le but d'obtenir la fonction attendue Définition des éléments d'identification d'une trame de type “IM” permettant de commander le module “Asservissement”: Dans ce cas, la trame envoyée par le contrôleur CAN (Circuit SJA1000 sur carte CAN_PC104) sera vue par le récepteur (circuit MCP25050 sur module) comme une IM “Input message”, avec la fonction Write register (voir documentation technique du MPC25025 pages 22). On pourra ainsi modifier les différents registres du module “Asservissement”. L’identificateur défini dans le chapitre 1, pour un “IM” envoyé à la carte “Asservissement”est : 0x00880000 (label: Ident_T_IM_Asservissement)

• Définition de variables structurées sous le modèle “Trame”: Trame T_IM_Asservissement;
• Définition des éléments d'identification de la variable structurée T_IM_Asservissement

  T_IM_Asservissement.trame_info.registre=0x00;  //On initialise tous les bits à 0
  T_IM_Asservissement.trame_info.champ.extend=1; //On travaille en mode étendu
  T_IM_Asservissement.trame_info.champ.dlc=0x03; //Il y aura 3 octets de données 
  T_IM_Asservissement.ident.extend.identificateur.ident=Ident_T_IM_Asservissement; 

A chacune des trames de commande “IM” il y aura donc à définir les trois octets associés.

Trame n°1 → pour définir les entrées et sorties du module “Asservissement” Il faut initialiser le registre GPDDR (“Data Direction Register”) en écrivant un 1 si bit d'entrée et un 0 si bit de sortie(doc MCP25050 p27). D'après schéma structurel de la carte “Asservissement” donné en Annexe:

GP7=fs -> entrée; GP6=fcg -> entrée; GP5=fcd -> entrée; GP4=ValidIP -> sortie;
GP3=PWM1 -> sortie; GP2=PWM2 -> sortie; GP1=AN1 -> entrée; GP0=AN0 -> entrée;
T_IM_Asservissement.data[0]=0x1F; // Adresse du registre GPDDR en écriture (doc MCP25050 page 16) 
T_IM_Asservissement.data[1]=0x7F; // Masque: bit 7 non concerné (doc MCP25050 page 16) 
T_IM_Asservissement.data[2]=0xE3; // Valeur: à charger dans le registre adressé

Suite à ces définitions, il faudra: * envoyer la trame par la fonction Ecire_Trame(T_IM_Asservissement) * puis attendre la réponse de type “Ack” en utilisant la fonction Lire_Trame(&T_Recue)

Trame n°2 → pour initialiser la sortie GP2 en sortie PWM1 (commande du moteur dans le sens positif) D'après la notice technique du circuit MCP25050 (pages 30 à 32), la génération du signal PWM1 se fait à partie du Timer1 et la fréquence de ce signal est choisie grâce au registre T1CON d'adresse 05H (page 15 Doc MCP25050).

bit 7 =1  	TMR1ON	Validation du "Timer 1"
bits 5:4	seront mis à 0 pour avoir un coefficient de division de fréquence égal à 1 ("TMR1 prescaler value" = 1)
T_IM_Asservissement.data[0]=0x21; // Adresse du registre T1CON en écriture (doc MCP25050 p15) 05H + décalage = 05H + 1CH = 21H
T_IM_Asservissement.data[1]=0xB3; // Masque sur le registre (doc MCP25050 p32) 
T_IM_Asservissement.data[2]=0x80; // Valeur à charger dans le registre adressé

Suite à ces définitions, il faudra

• envoyer la trame par la fonction Ecrire_Trame(T_IM_Asservissement)
• puis attendre la réponse de type “Ack” en utilisant la fonction Lire_Trame(&T_Recue)

Trame n°3 → pour définir la fréquence de la sortie PWM1: Cette fréquence dépend de la valeur chargée dans le registre “PR1”

T_IM_Asservissement.data[0]=0x23; // adresse du registre PR1 en écriture (doc MCP25050 p15) 07H + décalage = 07H + 1CH = 23H
T_IM_Asservissement.data[1]=0xFF; // Masque sur le registre (doc MCP25050 p32) 
T_IM_Asservissement.data[2]=0xFF; // On chargera 255 dans le registre

La fréquence du quartz implanté sur la carte “asservissement” étant égale à 16Mhz, la fréquence du signal PWM1 sera donc égale à : FPWM = 16.106/(4.256) = 15,6 KHz Ce qui est une fréquence correcte pour piloter un moteur en PWM (fréquence sensiblement inaudible).

Suite à ces définitions, il faudra

• envoyer la trame par la fonction Ecrire_Trame(T_IM_Asservissement)
• puis attendre la réponse de type “Ack” en utilisant la fonction Lire_Trame(&T_Recue)

Trame n°4 → pour définir le rapport cyclique de la sortie PWM1 (module de la commande donc de la vitesse du moteur)

T_IM_Asservissement.data[0]=0x25; //adresse du registre PWM1DCH en écriture (doc MCP25050 p15) 09H + décalage = 09H + 1CH = 25H
T_IM_Asservissement.data[1]=0xFF; //masque sur le registre (doc MCP25050 p33)
T_IM_Asservissement.data[2]=0x7F; // Commande =127 (0xFF=255 pour la commande Maxi) 

Suite à ces définitions, il faudra

• envoyer la trame par la fonction Ecrire_Trame(T_IM_Asservissement)
• puis attendre la réponse de type “Ack” en utilisant la fonction Lire_Trame(&T_Recue)

Pour démarrer (ou arrêter) le moteur, on agira alors sur le signal ValidIP soit la sortie GP4

• pour valider le circuit de puissance (démarrer le moteur)

  T_IM_Asservissement.data[0]=0x1E; //adresse du registre GPLAT en écriture
  T_IM_Asservissement.data[1]=0x10; //masque sur le registre (doc MCP25050 p27) 	
  T_IM_Asservissement.data[2]=0x10; //On positionne le bit GP4 du registre à 1 

• pour inhiber le circuit de puissance (arrêter le moteur)

  T_IM_Asservissement.data[0]=0x1E; //adresse du registre GPLAT en écriture
  T_IM_Asservissement.data[1]=0x10; //masque sur le registre (doc MCP25050 p27) 	
  T_IM_Asservissement.data[2]=0x00; //On positionne le bit GP4 du registre à 0 

Définitions des trames pour configurer et interroger le module commodo E.G. (Voir TP Exemple n°1)

/************************************************************************************************
*       TPs sur  EID210 / Réseau CAN - VMD  (Véhicule Multiplexé Didactique)  					
*************************************************************************************************
*       APPLICATION: Commande Essuie-glace à distance
*************************************************************************************************
*  	TP Exemple n°2:  Marche Arrêt du moteur + vitesse réglable par commodo Essuie-Glace 		
*------------------------------------------------------------------------------------------------		
*   CAHIER DES CHARGES :					      						
*  *********************						      						
*   On souhaite que l'etat du moteur (marche ou arret) suive l'etat de BP1 (GP4)
*    La vitesse du moteur sera fonction de l'entrée analogique 0 du commodo EG
*----------------------------------------------------------------------------------------------	
*  NOM du FICHIER :  TP_Exemple 2.C			       						
* ***************** 													
*************************************************************************************************/
// Fichiers à inclure
//********************
#include <stdio.h>
#include "Structures_Donnees.h"
#include "cpu_reg.h"
#include "eid210_reg.h"
#include "Can_vmd.h"
#include "Aton_can.h"
//==========================
//  FONCTION PRINCIPALE
//==========================
main()
{// Définition de variables locales
int Compteur_Passage;
char Commodo_EG_Mem;
unsigned int Cptr_TimeOut;
unsigned char AN0H; // Pour mémoriser les 8 biits de poids forts du résultat de conversion A->N
unsigned char Val_Vitesse,Val_Vitesse_Mem;
Trame Trame_Recue; 
Trame T_IRM_Commodo_EG;		// Trame pour interroger Module 8E sur Commodo Essuie Glace  
					// IRM -> Information Request Message -> Trame interrogative
Trame T_IM_Commodo_EG;		// Trame pour commander le Module 8E sur Commodo Essuie Glace  
					// IM -> Information Message -> Trame de commande
Trame T_IM_Asservissement;	// Trame pour commander le module "Asservissement" 
					// IM -> Information Message -> Trame de commande
// Initialisations
//*****************
 
/* Initialisation DU SJA1000 de la carte PC104 */
Init_Aton_CAN();
// Pour initialiser les liaisons en entrées  noeud "Commodo_EG"
T_IM_Commodo_EG.trame_info.registre=0x00;
T_IM_Commodo_EG.trame_info.champ.extend=1; // On travaille en mode étendu
T_IM_Commodo_EG.trame_info.champ.dlc=0x03; // Il y aura 3 données de 8 bits (3 octets envoyés)
T_IM_Commodo_EG.ident.extend.identificateur.ident=Ident_T_IM_Commodo_EG;
T_IM_Commodo_EG.data[0]=0x1F;	// première donnée -> "Adresse" du registre concernée 
						//(GPDDR donne la direction des I/O) adresse = 1Fh  page 16
T_IM_Commodo_EG.data[1]=0x7F; // deuxième donnée -> "Masque" 
					  //-> Tous les bits concernés sauf GP0 (voir doc page 16)
T_IM_Commodo_EG.data[2]=0x7F; // troisième donnée -> "Valeur" -> Tous les bits en entrée
// Envoi trame pour définir de la direction des entrées sorties
Ecrire_Trame(T_IM_Commodo_EG);  // Envoyer trame sur réseau CAN
	 Cptr_TimeOut=0;
	 do{Cptr_TimeOut++;}while((Lire_Trame(&Trame_Recue)==0)&&(Cptr_TimeOut<2000));
	 if(Cptr_TimeOut==2000)
		{ clsscr();
		  gotoxy(2,12);
		  printf(" Pas de reponse a la trame de commande en initialisation \n");
		  printf(" Couper et/ou  remettre    alimentation 12 V  \n");
		  do{}while(Lire_Trame(&Trame_Recue)==0); // On attend les trames  "On Bus"
              for(Cptr_TimeOut=0;Cptr_TimeOut<200000;Cptr_TimeOut++);
              Ecrire_Trame(T_IM_Commodo_EG);  // Renvoyer trame IM sur réseau CAN
	 	  Cptr_TimeOut=0;
	 	  do{Cptr_TimeOut++;}while((Lire_Trame(&Trame_Recue)==0)&&(Cptr_TimeOut<2000));
	 	  if(Cptr_TimeOut==2000)
			{ gotoxy(2,12);
		   	 printf(" Pas de reponse a la trame de commande en initialisation \n");
		  	 printf("  Modifier le programme et recommencer  \n");
	        	 do{}while(1); // On reste bloqué, on ne continue pas
			} 
		}
// Pour activer les conversions Ana -> Num
T_IM_Commodo_EG.data[0]=0x2A; 	// Adresse du registre ADCON0  
T_IM_Commodo_EG.data[1]=0xF0; 	// Masque -> bits 7..4 concernés
T_IM_Commodo_EG.data[2]=0x80;	// Valeur ->  ADON=1 et "prescaler rate"=1:32
Ecrire_Trame(T_IM_Commodo_EG);
do{}while(Lire_Trame(&Trame_Recue)==0); // Attendre réponse
// Pour définir le mode de conversion
T_IM_Commodo_EG.data[0]=0x2B; 	// Adresse du registre ADCON1  
T_IM_Commodo_EG.data[1]=0xFF; 	// Masque -> tous les bits sont concernés
T_IM_Commodo_EG.data[2]=0x0C;	// Valeur ->  voir doc MCP25050 page 36
Ecrire_Trame(T_IM_Commodo_EG);
do{}while(Lire_Trame(&Trame_Recue)==0); // Attendre réponse
// Pour initialiser le module "Asservissement"
// Trame de type "IM" (trame de commande): Données d'identification pour le noeud "Asservissement"
T_IM_Asservissement.trame_info.registre=0x00;
T_IM_Asservissement.trame_info.champ.extend=1;
T_IM_Asservissement.trame_info.champ.dlc=0x03;
T_IM_Asservissement.trame_info.champ.rtr=0;
T_IM_Asservissement.ident.extend.identificateur.ident=Ident_T_IM_Asservissement;
// Pour définir des Entrées/Sorties
T_IM_Asservissement.data[0]=0x1F; 	// Adresse du registre GPDDR  (direction de E/S)
T_IM_Asservissement.data[1]=0xEF; 	// Masque -> Bit 7 non concerné 
T_IM_Asservissement.data[2]=0xE3;	// Valeur ->  1 si Entrée et 0 si Sortie
	// GP7=fs Entrée; GP6=fcg Entree; GP5=fcd Entrée;  GP4=ValidIP Sortie; 
	// GP3=PWM2 Sortie; GP2=PWM1 Sortie; GP1=AN1 Entrée; GP0=AN0 Entrée; 
Ecrire_Trame(T_IM_Asservissement);
do{}while(Lire_Trame(&Trame_Recue)==0); // Attendre trame réponse (acquitement)
// Pour mettre à 0 les sorties 
T_IM_Asservissement.data[0]=0x1E; 	// Adresse du registre GPLAT  (Registre I/O)
T_IM_Asservissement.data[1]=0x1C; 	// Masque -> sorties GP4,3,2 sont consernées
T_IM_Asservissement.data[2]=0x00;	// Valeur ->  les 3 sorties sont forcée à 0  (ValidIP=0)
Ecrire_Trame(T_IM_Asservissement);
do{}while(Lire_Trame(&Trame_Recue)==0); // Attendre réponse (acquitement)
// Pour définir sortie GP2 en PWM1  
T_IM_Asservissement.data[0]=0x21; 	// Adresse du registre T1CON
T_IM_Asservissement.data[1]=0xB3; 	// Masque -> seuls bit 7;5;4;1;0 consernés
T_IM_Asservissement.data[2]=0x80;	// Valeur ->  TMR1ON=1; Prescaler1=1
Ecrire_Trame(T_IM_Asservissement);
do{}while(Lire_Trame(&Trame_Recue)==0); // Attendre réponse (acquitement)
// Pour définir fréquence signal sortie PWM1  
T_IM_Asservissement.data[0]=0x23; 	// Adresse du registre PR1
T_IM_Asservissement.data[1]=0xFF; 	// Masque -> tous les bits sont consernés
T_IM_Asservissement.data[2]=0xFF;	// Valeur ->  PR1=255
Ecrire_Trame(T_IM_Asservissement);
do{}while(Lire_Trame(&Trame_Recue)==0); // Attendre réponse (acquitement)
 
// Pour trame interrogative envoyée au commodo Essuie-Glace  -> 'IRM'   (Information Request Message)
// Définir données d'identification
T_IRM_Commodo_EG.trame_info.registre=0x00;
T_IRM_Commodo_EG.trame_info.champ.extend=1;
T_IRM_Commodo_EG.trame_info.champ.dlc=0x08;   // On attend 8 octets en réponse
T_IRM_Commodo_EG.trame_info.champ.rtr=1;
T_IRM_Commodo_EG.ident.extend.identificateur.ident=Ident_T_IRM8_Commodo_EG;
							// Voir définitions dans fichier CAN_VMD.h
Ecrire_Trame(T_IRM_Commodo_EG); // On envoi une première trame interrogative pour initialiser la mémoire
do{}while(Lire_Trame(&Trame_Recue)==0);
Commodo_EG.valeur=Trame_Recue.data[1]&0x10;
Commodo_EG_Mem=Commodo_EG.valeur;  // On met en mémoire l'état actuel pour comparaison ultéérieure
 
Val_Vitesse=Trame_Recue.data[2]; // On récupére les MSB de la conversion A->N  voie AN0 
// Pour initialiser rapport cyclique PWM1 -> c'est le module de la commande    
T_IM_Asservissement.data[0]=0x25; 	// Adresse du registre PWM1DC
T_IM_Asservissement.data[1]=0xFF; 	// Masque -> tous les bits sont consernés
T_IM_Asservissement.data[2]=Val_Vitesse;	// Valeur ->PWM1DC   commande égale à 50% (car valeur maxi=255)
Ecrire_Trame(T_IM_Asservissement);  // Le moteur ne peut tourner car ValidIP=0
do{}while(Lire_Trame(&Trame_Recue)==0); // Attendre réponse
Val_Vitesse_Mem=Val_Vitesse;  // On met en mémoire la valeur pour comparaison ultéérieure
 
// Les initialisations se sont bien passée
// On peut afficher le titre du TP
clsscr();
gotoxy(1,2);
printf("    *************************************************************** \n");
printf("      TPs sur Reseau CAN    Application: Commande Essui-glace       \n");
printf("      ------------------------------------------------------------  \n");
printf("      TP n° 4         Marche/Arret du moteur                        \n");
printf("      Le moteur est en etat MARCHE si on appuie sur BP1 (GP4)       \n");
printf("      Modifier l'entrée analogique pour modifier la vitesse         \n");
printf("    *************************************************************** \n");
 
// Pour afficher l'état initial
 	gotoxy(2,10);
	printf("  Etat entree GP4 (BP1) = %d \n",Commodo_EG.bit.GP4);  
	if(Commodo_EG.bit.GP4)printf("   Moteur a l'arret     \n");  
	else {printf("   Moteur en marche     \n"); 
		T_IM_Asservissement.data[0]=0x1E; 	// Adresse du registre GPLAT  (Registre I/O)
		T_IM_Asservissement.data[1]=0x10; 	// Masque -> seule la sortie ValidIP sera consernée
		T_IM_Asservissement.data[2]=0x10; // ValidIP =1 donc moteur en marche
		Ecrire_Trame(T_IM_Asservissement);  // Le moteur ne peut tourner car ValidIP=0
		do{}while(Lire_Trame(&Trame_Recue)==0); // Attendre réponse
	      }	
	gotoxy(2,14);
	printf("  Valeur entree analogique = %d \n",Val_Vitesse);  // On affiche sa valeur
 
// Boucle principale
//*******************
   do
	{  Ecrire_Trame(T_IRM_Commodo_EG); // On envoi trame interrogative au noeud commodo Essuie-Glace
         // On attend la réponse
	   do{}while(Lire_Trame(&Trame_Recue)==0);  // La fonction renvoie 1 dans ce cas
		if (Trame_Recue.ident.extend.identificateur.ident==Ident_T_IRM8_Commodo_EG)
			{ // On a reçu l'état du commodo donc on affiche les nouveaux états
			// Pour l'entrée Marche/Arret
			Commodo_EG.valeur=Trame_Recue.data[1]&0x10;
			if(Commodo_EG.valeur!=Commodo_EG_Mem)
				{// S'il y a eu changement, on commande le moteur
			        gotoxy(2,10);
			        printf("  Etat entree GP4 (BP1) = %d \n",Commodo_EG.bit.GP4);  // On affiche sa valeur
				 if(Commodo_EG.bit.GP4) // On test GP4 (BP1) du commodo EG
				 {// BP1 est relaché car l'entrée vaut 1
				  T_IM_Asservissement.data[0]=0x1E; 	// Adresse du registre GPLAT  (Registre I/O)
				  T_IM_Asservissement.data[1]=0x10; 	// Masque -> seule la sortie ValidIP sera consernée
				  T_IM_Asservissement.data[2]=0x00; 	// ValidIP =0 donc moteur à l'arret
				  printf("   Moteur a l'arret     \n"); 
				  Ecrire_Trame(T_IM_Asservissement);  
				  do{}while(Lire_Trame(&Trame_Recue)==0); // Attendre réponse
				 }
				 else
				 {// dans la cas contraire BP1 est appuyé 
				  T_IM_Asservissement.data[0]=0x1E; 	// Adresse du registre GPLAT  (Registre I/O)
				  T_IM_Asservissement.data[1]=0x10; 	// Masque -> seule la sortie ValidIP sera consernée
				  T_IM_Asservissement.data[2]=0x10; // ValidIP =1 donc moteur en marche
				  printf("   Moteur en marche     \n"); 
				  Ecrire_Trame(T_IM_Asservissement);  
				  do{}while(Lire_Trame(&Trame_Recue)==0); // Attendre réponse
				 }
			      }// Fin si changement 
			 Commodo_EG_Mem=Commodo_EG.valeur;  // On met en mémoire l'état actuel
			// Pour l'entrée analogique
			Val_Vitesse=Trame_Recue.data[2]; // On récupére les MSB de la conversion A->N  voie AN0 
			if(Val_Vitesse!=Val_Vitesse_Mem)
			  {	  gotoxy(2,14);
			        printf("  Valeur entree analogique = %d \n",Val_Vitesse);  // On affiche sa valeur
   			   // Pour modifier le rapport cyclique PWM1 -> c'est le module de la commande    
			   T_IM_Asservissement.data[0]=0x25; 	// Adresse du registre PWM1DC
			   T_IM_Asservissement.data[1]=0xFF; 	// Masque -> tous les bits sont consernés
			   T_IM_Asservissement.data[2]=Val_Vitesse;	// Valeur ->PWM1DC   
			   Ecrire_Trame(T_IM_Asservissement);  // Le moteur ne peut tourner car ValidIP=0
			   do{}while(Lire_Trame(&Trame_Recue)==0); // Attendre réponse
			  }
			Val_Vitesse_Mem=Val_Vitesse;
			} // Fin si identificateur correct	
	}while(1);// FIN de la boucle principale
}// FIN fonction principale