MoteurSynchrone2019

Partie 1:Projet

Description

L’objectif principal de ce projet était de piloter les trois phases d’un moteur synchrone à l'aide d’un microcontrôleur ou d’un FPGA. Pour cela il a fallu dans un premier temps comprendre le projet, faire une étude afin de définir les différentes tâches à réaliser pour mener à bien le projet. Après compréhension et étude du projet les différentes grandes tâches que l'on a défini furent :

• La programmation des MLI OU PWM
• L’étude et la programmation du capteur de position (codeur incrémental)
• L’étude et la réalisation de la carte
• La supervision
• La fabrication des pièces mécaniques

Schéma fonctionnel

Matériel

La liste du matériel utilisé est la suivante:

DESIGNATION	LOGICIEL
Carte Arduino leonardo	Freecad
Driver de MOS A4935	Arduino
codeur incrémental	Eagle
moteur synchrone	QT céator
RaspberryPi	LTSpice
Imprimante 3D	Excel

Cahier de charge du projet

Objectif du projet

comme objectif final nous devons piloter les trois phases du moteur synchrone LMT Lehner 3060 afin de pouvoir modifier la vitesse et le couple suivant ce l'on veut faire.

Etude du projet

Compréhension du projet, définitions des différentes taches à effectuer, recherche des solutions techniques les mieux adaptées, prévenir les éventuelles problèmes.

Réalisation de la carte

Élaboration du schéma à partir des cartes de DRIVER DE MOS(A4935 schéma board) et de l'arduino léonardo, étude et dimensionnement des différents composants, saisi du schéma sur et routage de la carte sur Eagle, élaboration de la liste des composants et fabrication.

Capteur de position

Choisir le capteur le mieux adapter, étudier son fonctionnement, comprendre comment il doit être câbler puis écrire le programme adapter pour pouvoir récupérer l'angle entre le stator et le rotor du moteur.

Réalisation du code principal

à l'aide de la carte DRIVER DE MOS de chez Allégro(A4935) et de la léonardo effectuer le câblage des deux cartes, écrire un code qui doit gener des MLI, faire un asservissement de courant, récupérer l'angle capter par le codeur et l'afficher.

Système de supervision

Élaborer le code permettant de récupérer la vitesse, la position du champs rotorique (l'angle entre le rotor et le stator),éventuellement le courant et les défauts afin prévenir les dysfonctionnements puis les afficher à l'aide d'un système d'affichage (RaspberryPi, écran lcd ,afficheur 7 segments...).

Mécanique

à l'aide des solutions mis en place c'est à dire logiciel de conception et imprimante 3D réaliser les différentes pièces.

Teste

Afin de vérifier le bon fonctionnement réaliser les différents testes.

Partie 2: Fabrication de la carte électronique

Saisie du schéma

Pour fabriquer une bonne carte électronique , on doit se focaliser sur les points suivants:

• Comment fonctionne le driver ?
• A quoi sert le driver ?
• Pourquoi tous ces transistors ?

Les premières informations que nous avons récupéré sont grâce au schéma fonctionnel suivant:

Le A4935 est conçu pour piloter des transistors MOS sur 3 phases différentes avec des alimentations séparées pour la logique et pour les sections analogiques et de pilotage. Il fournit les grands courants transitoires nécessaires pour charger et décharger rapidement la capacité de la grille du transistor externe afin de réduire la dissipation dans le transistor interne pendant la commutation. Le A4935 comprend un certain nombre de dispositifs de protection contre les sous-tensions, les surchauffes et les défauts du pont de puissance. En plus de ces défauts , il intègre des moniteurs drain-source pour chaque transistor externe afin de détecter les courts-circuits. Deux sorties FF1 et FF2 sont fournies pour signaler les défauts détectés à un contrôleur externe.

On constate qu'il y'a six commandes de grille. Chaque commande peut être commandée par une entrée de niveau logique compatible avec une logique de 3,3 ou 5 V.Le contrôle total des six transistors de puissance dans le pont triphasé est assuré, ce qui permet d'entraîner les moteurs avec une commutation par bloc . Les transistors de puissance sont protégés contre le passage par un contrôle intégré de croisement et un temps mort réglable par résistance.

Le but est de déterminer les valeurs des différents composants qui lui seront associés.

Il faudra également déterminer quels signaux logiques, et sur quelles entrées ceux-ci iront afin de choisir un mode de fonctionnement approprié.

Pour faire notre schéma , il a fallu faire connaissance de la datasheet du microcontrôleur ATMEGA32u4 (http://ww1.microchip.com/downloads/en/devicedoc/atmel-7766-8-bit-avr-atmega16u4-32u4_datasheet.pdf) et celle du driver A4935 Fichier:A4935-Datasheet (3).pdf

Routage

Il est évident d'essayer de respecter les consignes de bases pour fabriquer une bonne carte électronique.

Vu le nombre de composants à placer on se retrouve avec beaucoup de vias.

Les pistes en sortie des composants A4935 et ATMEGA32U4 sont les moins larges possibles afin de ne pas avoir de contact entre les différentes pattes. On a mis les noms des composants afin de pouvoir les repérer plus simplement, sans forcément avoir le board à portée. Le composant A4935 et les transistors n'étant pas présents de base dans les librairies d'Eagle, on a du les créer pour l'occasion. On a commencé par placer les plus petits composants avec de la pâte à braser, suivit d'un passage au four. Le reste des composants (potentiomètres, borniers) sont soudés de manière normale. Les pattes de ce composant étant extrêmement petites, plusieurs complications se sont rajoutées afin d'éviter les liaisons non voulues entre les pattes.

Test de la carte

Après la réalisation de la carte, on a pu faire quelques tests afin de dépanner les éventuelles erreurs

1er test

Vérification de la communication avec le microcontrôleur.

Dans un terminal on a lancé la commande

• avrdude -c avrisp2 -P usb -p m32u4

Liaison série entre le PC et la carte

Rien de plus simple que d'écrire ce bout de programme!!! .

 void setup() {
 Serial.begin(9600);
 }
 void loop() {
 Serial.println("coucou");
 }

Communication entre la carte et le codeur

Afin de connaitre la position du moteur à tout instant, on utilise le codeur rotatif. Pour tester la communication entre ces deux , on a repris le programme du codeur rotatif relaté dans la partie codeur rotatif mais cette fois avec les pattes compatibles à notre carte.

Et pour faire cette partie, on a utilisé le matériel suivant:

• nappe de 1m à 2m
• connecteur molex
• barrette mâle-femelle sécable
• gaine thermorétractable
• pince à dénuder

Partie 3: Programmation

L'objectif de la programmation est de pouvoir contrôler le pilotage du moteur par le biais d'un microcontrôleur. Nous allons ici utiliser l'Arduino Leonardo. Nous avons fait ce choix à cause des caractéristiques de son microcontrôleur(ATMEGA32u4) principalement le timer 4 avec:

• trois sorties PWM et leurs complémentaires
• une fréquence d'horloge allant à 64Mhz
• une grande vitesse de chronométrage et de comptage
• une haute résolution et une grande précision

Le travail se fera en plusieurs étapes. D'abord, nous allons générer des MLI, ensuite mesurer les valeurs instantanées de l'angle au rotor grâce au codeur incrémental et enfin faire une supervision du pilotage du moteur.

En ce qui concerne le programme,nous avons réfléchis à divers algorithmes comme suit:

Générer des MLI

Le moteur qui fait objet de notre étude est un moteur brushless triphasé ci-contre. Ce moteur est alimenté par une tension triphasée déphasée chacune de 2π/3 et nous disposons d'une tension d'alimentation continue.Il faut donc veiller à transformer cette tension continue en tension sinusoïdale. Pour ce fait, nous allons générer trois MLI en faisant usage du timer 4 du microcontrôleur. Une MLI (Modulation de largeur d'impulsions ou PWM pulse width modulation) est un signal logique qui vaut soit 0 ou 1 dont on peut varier le rapport cyclique et pour lequel la fréquence est fixe. Elle permet de faciliter la commande des transistors dont nous ferons usage pour piloter notre moteur. Ici, nous aurons besoin de trois MLI et de leurs opposées donc six MLI au total pour commander trois demi-pont fonctionnant par paire. Pour éviter que deux transistors de la même paire fonctionnent simultanément, on fera appel aux entrées xHI et xLO du driver.

Partir des notions de base

La liste du matériel utilisé est la suivante:

DESIGNATION	QUANTITE	VALEUR
led	6
resistance	6	330Ω
resistance	6	10KΩ
condensateur	6	150nF
carte arduino		leonardo
platine d'essai

Dans un premier temps, il a fallu prendre connaissance de la datasheet (http://ww1.microchip.com/downloads/en/devicedoc/atmel-7766-8-bit-avr-atmega16u4-32u4_datasheet.pdf) du microcontrôleur.Nous avons ensuite fais des tests sur platine d’essai afin de visualiser la forme du signal obtenu, la fréquence, de régler le temps de commutation entre les transistors sur un oscilloscope et d’avoir une idée visuelle des MLI grâce au clignotement des leds. Le programme suivant nous a permis de réaliser ses différents tests.

Fichier : codeMLI

 int main()
 {
  //CONFIGURATION DES SORTIES
  DDRB|= (1<<PB5)|(1<<PB6);
  DDRD|= (1<<PD6)|(1<<PD7);
  DDRC|= (1<<PC6)|(1<<PC7);
  
  //CHOIX DU MODE PWM
  TCCR4A|=(1<<PWM4A)|(1<<PWM4B);
  TCCR4C|=(1<<PWM4D);
  //TCCR4D &=~ (1<<WGM41)|(1<<WGM40); // ON PEUT LAISSER CETTE CONFIGURATION
  
  // CHOIX DU PRESCALER DIVISION PAR 1024
  TCCR4B|=(1<<CS41)|(1<<CS40);
  //TCCR4B &=~ (1<<CS42);(1<<CS41);(1<<CS40)(1<<CS43);
  
  // DIVISION DU TEMPS MORT *8
  TCCR4B|=(1<<DTPS41)|(1<<DTPS40); 
  
  // CONNEXION DE COMPLEMENTARITE ENTRE LES BROCHES
  TCCR4A|=(1<<COM4A0)|(1<<COM4B0);
  //TCCR4A &=~(1<<COM4A1)|(1<<COM4B1);
  TCCR4C|=(1<<COM4D0);
  //TCCR4C &=~(1<<COM4D1);

  //VALEUR MAXIMALE DU COMPTEUR
   OCR4C=255;

  // TEMPS MORT
  DT4 |= 1<< DT4L1;
  while(1)
  {
    OCR4A++;
    OCR4B++;
    OCR4D++;
    _delay_ms(20);
  }
 }

Le signal obtenu à l’oscilloscope est le suivant :

Filtre passe-bas

Apres cette étape, il a fallu réaliser un filtre passe-bas afin de récupérer la valeur moyenne du signal. Nous obtiendrons alors trois signaux de forme sinusoïdale. La fréquence des MLI générées est de 15Khz, nous avons réalisé un filtre passe-bas avec une fréquence de coupure de 100Hz. Nous avons faire une petite simulation sur Excel et le resultat est ce qui suit:

Certains calculs ont également été effectués afin de choisir la valeur des composants qui permettrait d'avoir la fréquence de coupure de 100Hz prédéfinie. On a réalisé un filtre simple pour un premier test. Les valeurs sont répertoriées dans le tableau ci-dessus.

Le programme a ainsi été modifié afin de prendre en compte le filtre et les valeurs prises par l'angle au stator du codeur (cette partie sera détaillée plus bas).On a ensuite ajouté un potentiomètre afin de contrôler l'amplitude de la tension et le rapport cyclique des MLI et on obtient ce qui suit:

Fichier : codeFiltre

   
 // DECLARATION DES VARIABLES
 // TABLEAUX
 const uint8_t tabA[34]= {120,142,163,182,199,214,225,232,235,234,229,220,207,191,173,153,131,109,88,67,49,33,21,11,6,5,8,15,26,40,58,77,98,120};
 const uint8_t tabB[34]= {225,214,199,182,163,142,120,98,77,58,41,26,15,8,5,6,11,20,33,49,67,87,109,131,152,173,191,207,219,229,234,235,232,225};
 const uint8_t tabD[34]=  {33,20,11,6,5,8,15,26,41,58,77,98,120,142,163,182,199,214,225,232,235,234,229,220,207,191,173,153,131,109,88,67,49,33};
 int i=0;
 int valpot;
 int valtabA,valtabB,valtabD;
 
 void setup() {
  Serial.begin (9600);
  Serial.println ("Start");
 
  //CONFIGURATION DES SORTIES
  DDRB|= (1<<PB5)|(1<<PB6);
  DDRD|= (1<<PD6)|(1<<PD7);
  DDRC|= (1<<PC6)|(1<<PC7);

  // MISE A ZERO DES REGISTRES
  TCCR4A = 0;
  TCCR4B = 0;
  TCCR4C = 0;
  
  //CHOIX DU MODE PWM
  TCCR4A|=(1<<PWM4A)|(1<<PWM4B);
  TCCR4C|=(1<<PWM4D);
  
  // CHOIX DU PRESCALER DIVISION PAR 1024
  TCCR4B|=(1<<CS41)|(1<<CS40);
  
  // DIVISION DU TEMPS MORT *8
  TCCR4B|=(1<<DTPS41)|(1<<DTPS40);
  
  // CONNEXION DE COMPLEMENTARITE ENTRE LES BROCHES
  TCCR4A|=(1<<COM4A0)|(1<<COM4B0);
  TCCR4C|=(1<<COM4D0);
  
  //VALEUR MAXIMALE DU COMPTEUR
   OCR4D=255;
   
  // TEMPS MORT
  DT4 |= 1<< DT4L1;

  //DECLARATION DE L'ENTREE A3
  pinMode(A3,INPUT);

 
  delay(5000);
 }

  void loop()
  {
    if (i==33) i =0; else i++;

    valpot = analogRead(A3);
    valtabA= ((valpot/8) * int(tabA[i]))/(1024/8);
    OCR4A = uint8_t(valtabA);
    valtabB= ((valpot/8) * int(tabB[i]))/(1024/8);
    OCR4B = uint8_t(valtabB);
    valtabD= ((valpot/8) * int(tabD[i]))/(1024/8);
    OCR4D = uint8_t(valtabD);
    //_delay_ms (1);
    Serial.print("valpot :");
    Serial.print(valpot);
    Serial.print(" ");
    Serial.print("valtabA :");
    Serial.println(valtabA);

    delay(250); //delay qui permet de nous laisser du temp pour lires les valeurs
 }

Les signaux visualisés à l'oscilloscope sont indiqués sur la figure suivante:

Codeur incrémental

Visuel + branchage sur l'arduino

Pour savoir quelle est la position du moteur en tout instant, on utilise un codeur rotatif. On utilise un HEDS-5540 de la famille Avao technologie pour nous donner les informations. On y place les fils sur l'arduino avec le fil noir pour le GND, le fil vert pour le Vcc, et les fils rouges, bleus et jaunes servent à donner, transmettre les informations du moteur à l'arduino Leonardo. Pour pouvoir utiliser les informations, on implante un programme arduino pour lire les informations du codeur. Pour cela, on a deux voies qui servent à détecter si le moteur va dans un sens ou dans un autre, et une voie qui permet de détecter le Top tour du moteur.

On va expliquer comment on arrive à lire et exploiter les informations du codeur :

Dans un premier temps, il fallait apprendre à lire les informations sur arduino, puis on doit gérer l'incrémentation et la décrémentation pour avoir un visuel de ce que fait le moteur avec des valeurs. Enfin, il fallait que le codeur puisse revenir à zéro pour savoir quand le moteur fait un tour complet.

Programme du codeur rotatif

Le void setup permet de configurer l'arduino en donnant la vitesse et configurant les fonctions utiles au programme.

  void setup() {
  Serial.begin (9600);
  Serial.println ("Start");
  attachInterrupt (1, Interrupt1, RISING);  //l'interruption pour pouvoir lire le front montant
  attachInterrupt (0, Interrupt2, FALLING); //l'interruption pour pouvoir lire le front descendant
  delay(5000);
  }

Le void loop sert juste à afficher les valeurs lues par le codeur.

 void loop(){
  Serial.println (val); //lire sur la console les angles lus par le codeur
  delay(250); //delay qui permet de nous laisser du temps pour lire les valeurs
 }

Le Interrupt sert à l'incrémentation, ou la décrémentation pour la seconde fonction, et qui enregistre les valeurs données par le codeur.

 
 void Interrupt1(){
  if ( bit_is_set (PINC,PC6) ){ //Top Tour
       val = 0;
    }else{
      if ( (bit_is_set(PIND,PD4) == 0) ){ //regarde le front montant
        if ( val == valMaxCapteur ){  //on regarde si on a la valeur max
        val = 0;
        }else{
          val++;
        }
      }else{
        if(val == 0){ //on regarde si on a la valeur min
          val = valMaxCapteur;
        }else{
          val--;
        }
      }
    }
 }

A noter que les PIN peuvent être changés suivant le besoin de l'utilisateur

Tests: Carte Demo

Dans cette partie du travail, notre carte était en cours de fabrication, on a donc fait usage de la carte demo A4935 fournie par le fabricant. Cette carte nous a permis de faire des tests et d'ajuster au fur et à mesure notre programme.

Après avoir mis en commun les deux programmes précédents, l’étape suivante était de trouver la formule juste pour les angles du stator et du rotor mesurent 90 degrés afin que le couple soit au maximum. Nous sommes partis du principe que: angle_stator = angle_rotor + offset et avons ajouté un second potentiomètre afin de pouvoir régler un offset approximativement correct. A la fin du test, ce potentiomètre a été retiré.

Ensuite nous avons essayer de faire un démarrage manuel suivant certaines contraintes du moteur. Ce qui,nous a amené à contrôler en permanence le fonctionnement correct du codeur grâce à l'oscilloscope.

Trois conditions sont nécessaires pour un démarrage optimal du moteur:

• le potentiomètre contrôlant le rapport cyclique des MLI doit être mis à zéro
• nous devons faire un tour complet du codeur
• les défauts relevés par le driver doivent avoir été supprimés

Afin d’éliminer les défauts, nous avons tenu compte de la partie de la datasheet relative à la gestion des défauts du composant A4935.

Après documentation, pour supprimer les défauts, nous devons mettre le reset du composant à zéro comme indiqué dans la table de vérité ci-dessus.

Durant les tests, on s'est aperçu qu'a partir d'une certaine valeur, le courant devenait instable. Il nous revient alors de faire l'asservir afin de contrôler la vitesse et le couple. On va alors se servir de l'amplificateur de courant que renferme le driver. Nous sommes partis d'une simple mesure de courant grâce aux résistances de shunt entre les pins CSP et CPN du driver. Le courant faible mesuré sera ainsi amplifié à la sortie CSOUT. Malheureusement, ce signal n'est pas parfait, on va réaliser un filtre passe-bas actif avec une fréquence de coupure 700Hz.

Pour dimensionner notre filtre, on a effectué des calculs sur la base des composants existants déjà sur la carte demo.

Tous les composants restent inchangés sauf la résistance Rf qui sera remplacée par un condensateur en parallèle avec une résistance comme la figure ci-dessus. Les nouvelles valeurs sont consignées dans le tableau suivant:

DESIGNATION	VALEUR
R15	75K
R16	3,9K
R14	75K
R11	8,2K
R12	8,2K
R2	10k
condensateur	100nF

Après les calculs et la réalisation du filtre, nous n'avons pas eu les résultats attendus car le signal obtenu oscillait. On a ensuite pensé diviser les valeurs par deux, le résultat était le même. Finalement, nous avons opté pour une simulation sur LTspice.

Supervision

Pour visualiser ce que fait le moteur, on utilise une carte Raspberry Pi 3. La principale difficulté est de pouvoir communiquer entre l'arduino, qui récupère les informations en binaire du moteur, à la Raspberry, qui traite des informations en numérique. On utilise pour cela un composant qui permet de transformer les informations binaires en numériques et inversement. Il faut aussi configurer la carte Raspberry pour qu'elle puisse recevoir ces informations. Pour cela nous nous aidons de ce lien pour configurer la Raspberry Pi ( https://spellfoundry.com/2016/05/29/configuring-gpio-serial-port-raspbian-jessie-including-pi-3-4/ ).

Etape 1

Pour vérifier la bonne connexion entre l'arduino et la Raspberry Pi, on utilise dans l'invite de commande à l'aide du minicom. On effectue ces tests avec de simples programmes. Pour pouvoir communiquer entre l'arduino et la Raspberry Pi, il faut configurer la vitesse avec les Serial. Sur QtCreator, on utilise la bibliothéque QtSerialPort ( https://doc.qt.io/qt-5/qserialport.html ) et QioDevice ( https://doc.qt.io/qt-5/qiodevice.html ), pour pouvoir utiliser la transmission de données. Dans le .h on ajoute dans le public slot une fonction pour pouvoir analyser les données reçues puis en private une valeur serial qui sera utiliser dans le .cpp. Dans le .cpp, on définit dans un premier temps l'utilisation QSerialPort pour qu'il soit à la même vitesse de transmission que l'arduino, puis on demande avec la fonction DataToRead de lire les informations données par l'arduino.

 MainWindow::MainWindow(QWidget *parent) :
   QMainWindow(parent),
   ui(new Ui::MainWindow)
 {
   ui->setupUi(this);
   serial.setPortName(QString("/dev/ttyAMA0"));                        //Permet de lire sur quelle entrée on communique
   serial.setBaudRate(9600);                                           //Vitesse de 9600 baud/s
   //serial.setParity(QSerialPort::MarkParity);                          //Mettre un bit de Parité pour vérifier l'information
   connect(&serial, SIGNAL(readyRead()), this, SLOT(dataToRead()));    //connect(&objet use,SIGNAL("prendre ceux proposé"),this,SLOT("notre fonction à use")
   serial.open(QIODevice::ReadOnly);                                   //Permet de lire les informations de l'arduino
 }

 void MainWindow::dataToRead(){
   char c;
   while (serial.waitForReadyRead())                                   //On attend les infos à transmettre pour l'use dans la boucle
   {
       serial.getChar(&c);
       qDebug() << c;
   }
 }

Etape 2

On doit faire envoyer les valeurs depuis l'arduino à la Raspberry en continu. Pour cela nous allons créer un message qui comportera un caractère de début, ici #, puis les valeurs séparées par un ; et enfin un $ pour montrer la fin du message et qu'il n'y a pas eu de problème lors de la transmission du message.

 void setup() {
  Serial.begin (9600);
  Serial1.begin (9600);
  delay(5000);
 }
 void loop()
 {
  val = analogRead(A3); //pouvoir lire les infos du potentiomètre sur l'arduino
  Serial.print("#");    //pour pouvoir avoir le début du message
  Serial1.print("#");
  Serial.print (val);   //lire sur la console les angles lus par le codeur
  Serial1.print(val);
  Serial.print("$");    //pour avoir la fin du message
  Serial1.print("$");
  delay(250);           //delay qui permet de nous laisser du temps pour lire les valeurs
 }

Dans QtCreator, dans la fonction DataToRead, on demande au programme de décoder les valeurs transmises par l'arduino puis de les afficher dans un display en affichage numérique.

NB : On peut mettre des qDebug() pour vérifier que le programme passe dans toute la boucle et ne soit pas coincé ce qui expliquerai pourquoi il y a des ralentissements ou freeze de l'écran de la Raspberry Pi.

 void MainWindow::dataToRead(){
    char c;
    while (serial.bytesAvailable() >3){                   //On attend les infos à transmettre pour l'use dans la boucle
        serial.getChar(&c);
        qDebug() <<"lit char";
        if (c=='#'){                                     //Permet de repérer le début du message
            bool messageValide = true;
            QString message;                             //Permet de ranger les infos de l'arduino dans une variable
            int i = 0;
            qDebug() << "ok debut !";
            do{                                          //on lit le getChar tant qu'on a pas le '$'
                serial.getChar(&c);
                qDebug() <<"LIT CHAR";
                if (c!='$'){                             //Si on a pas le '$' alors on range les infos ds message
                    message.append(c);
                    i++;                                 //On incrémente i à chaque passage dans la boucle ( sécurité )
                    qDebug() << "RECU: " << message;     //On regarde dans la console les valeurs qui passent
                }
            if (i == 5){                                 //Si i > 4 alors on a une erreur
                    messageValide = false;
                    qDebug() << "FAUX";
                }
            }while(c!='$');                              //Si on a '$' alors on affiche le message
            if (messageValide==true){                    //Si on a le message qui est bon alors on affiche le nombre ( sécurité )
                ui->Affichage_nombre->display(message);     //display permet d’utiliser le QLCNumber ( PS : ne pas oublier de l’incure )
                qDebug() << "Affichage";
            }else{
                qDebug() << "ERREUR";
            }
        }else{
            qDebug()<<" recu : "<<c;
        }
    }
 }

La méthode est la même lorsque l'on rajoute des valeurs sur l'arduino puis qu'elle est décodée sur Qt.

Etape 3

Ensuite il était prévu que l'on puisse commander le fonctionnement du moteur en envoyant une donné depuis Qt à l'arduino. Dans un premier il faut configurer la partie qui devaient envoyer cette donnée en créant une fonction qui va écrire à l'arduino, ici DataToWriteOn pour allumer le moteur (dans le principe) et DataToWriteOff pour l'éteindre.

serial.open(QIODevice::ReadWrite);                                   //Permet de lire les informations de l'arduino et d'émettre les infos pour l'arduino

Cette ligne à changer permet de lire et d'envoyer des données par l'arduino.

 void MainWindow::dataToWriteON(){
    serial.write("o");
    qDebug() << "ON";
 }

Même principe avec la fonction DataToWriteOff.

Ensuite sur arduino nous devons pouvoir lire cette information et, si nous pouvions le finir, donner l'information qui s’arrêterait ou s’allumerait suivant ce qu'on lui a demandé. Dans le void loop on rajoute juste cette ligne qui permettrait d'effectuer nos actions sur le moteur.

  if( Serial1.available() > 0 ) {   //Permet de savoir quand on reçoit une valeur
    incomingByte = Serial1.read();  //permet de mettre cette valeur dans une variable
    if ( incomingByte == 'o'){      //si on a 'o' alors on met ON sur la console arduino
      Serial.println ("ON");
    }
    if ( incomingByte == 'f'){      //si on a 'f' alors on met OFF sur la console
      Serial.println ("OFF");
    }
  }

Pour vérifier si on a bien les valeurs qui se transmettent, ici ON ou OFF, on prend un oscilloscope que l'on branche au patte du composant permettant de faire le switch entre numérique et analogique.

Etape 4

Pour finir, nous devons pouvoir visualiser la position du champ rotorique et statorique du moteur pour s'assurer qu'il ne s'emballe pas. Pour cela nous allons utiliser la librairie QGraphicscene ( http://tvaira.free.fr/projets/activites/activite-qt-dessin.html et https://doc.qt.io/qt-5/qgraphicsscene.html ) pour pouvoir les afficher. Une fois avoir déclaré les librairies dans Qt, on crée notre scene graphique dans le .cpp.

 void MainWindow::paintEvent(QPaintEvent *event){
    QPainter ellipsePainter(this);
    QPen pen;
    pen.setWidth(1);
    pen.setBrush(Qt::SolidPattern);
    ellipsePainter.setPen(pen);
    ellipsePainter.drawEllipse(100-75,100-75,150,150);  //2 premiers servent à placer le cercle - 2 derniers servent à la largeur puis hauteur du 
    cercle
    QPainter myline(this);
    QPen linePen(Qt::red);
    linePen.setWidth(5);
    myline.setPen(linePen);
    myline.drawLine(100,100, 100+x,100+y);              //2 premiers servent à positionner le point (x1,y1) - 2 derniers servent à positionner l'autre extrémiter (x2,y2)
    QPainter myline_2(this);
    QPen linePen_2(Qt::blue);
    linePen_2.setWidth(4);
    myline_2.setPen(linePen_2);
    myline_2.drawLine(100+x_2,100+y_2, 100+x,100+y);
 }

NB : x, y, x_2 et y_2 sont des variables déclarées en private dans le .h pour pouvoir s'en servir dans tout le programme.

Les valeurs de x, y, x_2 et y_2 sont récupérées depuis les informations transmises de l'arduino. On les utilise à la fin de la boucle de la fonction DataToRead.

            valDial = dial1.toInt();        //Permet de convertir de char à int
            valDial2 = dial2.toInt();
            if (dialValide==true){
                ui->dial->setValue(valDial);    //On montre la position valDial sur dial
                ui->dial_2->setValue(valDial2);
                radians = ((2*M_PI)*valDial) / 34 ;   //permet de convertir une valeur numérique en radian (34->2pi rad et x -> y rad)
                radians_2 = ((2*M_PI)*valDial2) / 34 ;
                //Calcul du cos et du sin pour les renvoyer au paintEvent
                x = 42 * qCos(radians);
                y = 42 * qSin(radians);
                x_2 = 77 * qCos(radians_2);
                y_2 = 77 * qSin(radians_2);
            }
            repaint();      //permet de le rafraîchir la fenêtre

Le calcul consiste en une fonction de trigonométrie pour connaitre l’hypoténuse et donc le trait qui permet de savoir quelle est la position du moteur. On effectue ainsi le calcul à la fin de la fonction DataToRead avant de l'envoyer à la fonction paintEvent. On a une fonction repaint() qui nous permet de rafraîchir la scene graphique et ainsi avoir la position en temps réel.

Voilà le résultat final avec deux affichages numériques pour la tension donnée et l'angle du moteur. Deux leds numériques qui nous préviennent lors du défaut du moteur. Deux boutons qui devaient servir à faire fonctionner ou arrêter le moteur sans intervention physique. Deux représentations graphiques, l'une avec des potentiomètres numériques et l'autre avec le Qgraphicscene, pour observer la position du moteur.

Partie 4: Mécanique

Description du travail à réaliser

Après les tests à vide du moteur on se doit de le tester en charge. Le but de cette partie était de réaliser des pièces d'accouplement et un support afin de connecter la charge au moteur et de réaliser des tests.

• il fallait démonter le moteur ci-contre afin de le remplacer par le notre.

à l'aide de clé plate, d'un jeu de btr et de quelques tournevis on a démonté le moteur

• trouver une solution pour monter et accoupler notre moteur pour effectuer les tests.

le problème qui se posait était de trouver comment faire pour que notre moteur de petite taille soit à la bonne hauteur afin que l'axe du moteur coïncide avec celui de la charge et trouver aussi une solution pour effectuer l'accouplement du moteur à la charge afin qu'il puisse l’entraîner en rotation. Donc pour se faire nous avions d'abord compris comment l'ancien moteur le faisait puis nous avons récupéré les pièces utiles,fait des mesures à l'aide d'un pied à coulisse mais pour la mesure de la hauteur entre plateau et l'axe de la charge nous sommes allés en GMP pour récupérer une colonne de mesure qui était beaucoup plus pratique q'un pied à coulisse.

• il fallait fabriquer les différentes pièces utiles au montage du moteur.

Après mesure il me fallait réaliser dans un premier temps les croquis des pièces (roue dentée et un support moteur) à la main puis dans un deuxième temps réaliser la conception sur freecad des pièces puis enfin les faire imprimer en 3D.

• Assemblage du moteur + alternateur et test.

Pour le maintien du support moteur, nous avons utilisé la solution vis écrous bien sur qui avait été récupéré sur l’ancien support et pour la roue dentée qui était fixée sur l'axe du moteur nous avons utilisé une vis de pression afin qu'il soit bien fixé sur l'arbre du moteur. Pour la liaison entre le moteur et la charge c'est-à-dire entre leur roue dentée, nous avons utilisé la encore la même qui a servit pour l'autre moteur ce qui a donné le résultat suivant.

Ressources

Composants utilisés

Nom	Boitier/valeur	Documentation/information
ATMEGA 32u4 microcontrôleur	CMS	ATMEGA32U4-AU datasheet
Driver A4935	CMS	Fichier:A4935-Datasheet (3).pdf et on a du créé une librairie puisque le composant n'existait pas
Régulateur de tension	Traversant	connecté avec des condensateurs de 100nF
ICSP	Traversant	broches de programmation MISO MOSI et SCK correspondent aux numéros de pattes 11,10 et 9 pour l'atmega32u4.
USB	Traversant	on a du utiliser l'USB puisque les pattes qu'on devait relier au codeur(RX et TX) étaient déjà utilisées
QUARTZ	16MHz	Avec une résistance de 1M
6 Transistors	CMS	le composant n'existait pas donc on l'a créé
4 Condensateurs de découplage	680nF
6 Résistances	100K	GHA-GLA-GHB-GLB-GHC-GLC
Potentiomètres	Traversant	avec une résistance de 50k
Diodes	Traversant
4 LEDS	CMS	Avec des résistances de 330
Douille	Traversant	Alimentation
3 Résistances	2,K	résistances de tirage reliées au codeur
2 Résistances	47K	reliées à FF1 et FF2 avec des leds afin de détecter les défauts
Condensateurs	100n et 10u(polarisé)	patte Vreg et alimentations
Résistances de shunt	0	connexion entre le microcontroleur et ALO-BLO-CLO , la patte CSP aussi
2 boutons poussoirs	Traversant
Cosses poignards	Traversant

Les différentes valeurs des condensateurs se calculent à partir des informations que l'on trouve dans la datasheet de l'A4935.

On a pas pu avoir les valeurs des composants du filtre passe-bas.

Fichier Eagle

Fichier:Projet (3).brd

Fichier:Projet (3).sch.sch

Chiffrage de la carte électronique

Après simulation sur le site jlcpb , on a pu avoir une petite carte double face à 6$20.

Reste à faire

• Finaliser réalisation du filtre passe-bas afin d'obtenir des sinusoïde.
• Effectuer l’asservissement en courant.
• Finaliser l'assemblage des différents codes(codeur et supervision) au code principale puis effectuer quelques ajustements.
• Effectuer des testes avec la carte réaliser voir si elle répond à nos attentes
• Réaliser des testes en charge du moteur en faisant varier la charge puis observer le fonctionnement répond au cahier des charges