Hello !
Trace:

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Next revision		Previous revision
fr:examples:can:wiper:tp2 [2010/03/03 15:11] – créée sdeniaudfr:examples:can:wiper:tp2 [2020/07/20 09:00] (current) – external edit 127.0.0.1
Line 1: Line 1:
-====== TP2 - Exemple ======+====== TP2 - Exemple 2 ====== 
 +===== Sujet: ===== 
 +**Marche/arrêt du moteur de l'essuie-glace.**
  
 +==== Objectifs : ====
 +
 +  * 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.
 +
 +==== Cahier des charges : ====
 +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".
 +
 +===== Elements de solution =====
 +==== Analyse ====
 +
 +**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''
 +<code c>
 +  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; 
 +</code>
 +
 +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:
 +<code c>
 +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é
 +</code>
 +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).
 +<code c>
 +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é
 +</code>
 +
 +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"
 +<code c>
 +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
 +</code>
 +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)
 +<code c>
 +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) 
 +</code>
 +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)
 +<code c>
 +  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 
 +</code>
 +  * pour inhiber  le circuit de puissance (arrêter le moteur)
 +<code c>
 +  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 
 +</code>
 +**Définitions des trames pour configurer et interroger le module commodo E.G.
 +(Voir TP Exemple n°1)** 
 +
 +==== Organigramme ====
 +
 +{{  :fr:examples:can:wiper:orga_2.png  |}}
 +
 +==== Programme en "C" ====
 +
 +<code c>
 +/************************************************************************************************
 +*       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
 +</code>
fr/examples/can/wiper/tp2.1267629096.txt.gz · Last modified: 2020/07/20 09:00 (external edit)
CC Attribution-Share Alike 4.0 International
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0