Go Down

Topic: Phare à LED (moteur pas à pas, commutation....), gyrophare (Read 2740 times) previous topic - next topic

iutgeiisoissons

Mar 30, 2018, 03:54 pm Last Edit: Apr 16, 2018, 08:29 am by iutgeiisoissons
Phare à LED pour Center Parc

Introduction :
Le but de ce projet est de créer une maquette de phare à LED pour le mini phare du Center Parc



Pour réaliser la maquette, nous avons utilisé des LED : U2 Laser Gun fonctionnant en 24V ainsi qu'une carte Arduino AT Mega 2560.


1/ Les LED U2 Laser Gun
Notre premier problème portait sur les LED qui proposaient 3 modes de fonctionnement :
- En intensité Forte
- En intensité Faible
- En clignotement

Le mode par défaut est le premier. Pour obtenir les autres modes, il suffit de couper et remettre l'alimentation. Un condensateur permet de créer une mémoire pour se souvenir du mode précédent. Cependant, nous n'avions besoin que du premier mode. Nous avons donc court-circuité le condensateur avec une résistance de 4.7kΩ sur chaque LED.


Court-circuiter le condensateur C2 ne fait qu'accélérer sa décharge, cependant vu que l'on a plusieurs LED, nous n'avons pas besoin d'une décharge immédiate. 1s est suffisante pour le résultat souhaité. Nous avons essayé de mettre une résistance plus petite valeur, cependant le condensateur se déchargeait trop vite et la LED ne s'allumait donc plus.

2/ Combien de LED doit on utiliser ?
Pour notre maquette, nous avons utilisé 12 LED uniquement, pour pouvoir avoir un angle de 30° entre chacune. Nous avions pour idée d'en mettre plus pour un projet final. 24 LED aurait permis de réduire l'angle par deux et d'améliorer la fluidité du mouvement.


3/ Comment contrôler les LED avec une carte Arduino ?
La carte Arduino fonctionnant en 5V et les LED fonctionnant en 24V, nous avons été obligé d'utiliser des transistors pour contrôler les LED :


Sur ce schéma ISIS, on remarque que l'alimentation en 12V (ou 24V) est connecté à toute les LED. On contrôle les transistors à l'aide des connecteurs J14 et J15 qui sont eux même connectés à la carte Arduino.
Remarque : On a mis des petites LED pour vérifier le fonctionnement du circuit même lorsqu'on ne connecte pas le phare.


Carte ARES


Le Schéma ISIS permet aisément de comprendre la Carte ARES. Cette carte a été réalisée de manière à pouvoir se mettre directement sur une carte Arduino Mega. La partie de droite correspond à la connectique utilisée pour l'affichage LED.

4/ Quel programme a-t-on réalisé ?

Notre premier programme était simple et servait uniquement à tester le fonctionnement des LED. On allumait puis éteignait une à une chaque LED avec un délai entre les deux pour simuler le fonctionnement d'un véritable phare

Code: [Select]


void setup() {
  for(int i=0;i<12;i++) // De 0 à 11 car on a 12 LED
  {
    pinMode(i, OUTPUT); //L1 est une broche de sortie
  }
}
void loop() {
    for(int i=0;i<12;i++)
    {
      digitalWrite(i, HIGH); //allumer L1
      delay(1000); // attendre 1 seconde
      digitalWrite(i, LOW); //allumer L1
    }
}


Ce code ne nous permettant pas de modifier la durée d'allumage de chaque LED, nous avons fait un autre programme utilisant un Timer pour changer le delay.

Code: [Select]

// include the library code:
#include <LiquidCrystal.h>
//#include <SoftwareSerial.h>             // inutilisé
#include <TimerOne.h>                   // inutilisé

//#define SERIAL_PORT_LOG_ENABLE 1
//#define Led     13       // 13 pour la led jaune sur la carte
#define BP1     30       // 30 BP1
#define BP2     31       // 31 BP2          
#define BP3     32       // 32 BP3
#define LEDV    33       // 33 led
#define LEDJ    34       // 34 led
#define LEDR    35       // 35 led
//#define relay   36       // 36 relay
//#define PWM10    10      //11   timer2    

LiquidCrystal lcd(27, 28, 25, 24, 23, 22); // RS=12, Enable=11, D4=5, D5=4, D6= 3, D7=2, BPpoussoir=26
// Configuration des variables
unsigned int Compt = 250; // Valeur du delay modifié par le Timer
void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.

  
  // put your setup code here, to run once:
  for(int i=0;i<12;i++)
  {
    pinMode(i, OUTPUT); //L1 est une broche de sortie
  }
  pinMode(32,INPUT); // On met BP3 en entrée pour qu'il puisse allumer toute les LED (debug)
  Timer1.initialize(10000); // On initialise le timer sur 0,1s
  Timer1.attachInterrupt(callback); On attache la fonction "callback" à la routine d'interruption
}
void callback() {
  if ((digitalRead(BP1))==1) // On ralenti la commutation des LED en appuyant sur BP1
    {
        Compt = Compt + 1;
    }
    if ((digitalRead(BP2))==1) // On accélère la commutation en appuyant sur BP2
    {
      if(Compt > 25) // Dans le cas ou Compt > 25 on arrète de décrémenter pour avoir une vitesse raisonnable
      {
        Compt = Compt - 1;
      }
      else Compt = 26;
    }
    if((digitalRead(BP3)) == 1) // On allume tout les LED si on appuie sur BP3
    {
      for(int i=0;i<8;i++)
    {
      digitalWrite(i, HIGH); //allumer L1
    }
    }
}
void loop() {
  // put your main code here, to run repeatedly:
//  if(digitalRead(32) == HIGH)
//  {
    for(int i=0;i<8;i++)
    {
      digitalWrite(i, HIGH); //allumer L1
       delay(Compt); // attendre 1 seconde
      digitalWrite(i, LOW); //allumer L1
    lcd.setCursor(9,0);      //colonne, ligne
    lcd.print("     ");
    lcd.setCursor(9,0);
    lcd.print(Compt);
    lcd.setCursor(1,0);      //colonne, ligne
    lcd.print("Delay = ");;
    lcd.setCursor(14,0);
    lcd.print("ms");
    lcd.setCursor(0,1);
    lcd.print("BP1=Inc  BP2=Dec");  
    }
}
//  else
//  {
//    for(int i=5;i>=0;i--)
//    {
//      digitalWrite(i, HIGH); //allumer L1
//      digitalWrite(i+6, HIGH); //allumer L1
//      delay(200); // attendre 1 seconde
//      digitalWrite(i, LOW); // Eteindre L1
//      digitalWrite(i+6, LOW); //allumer
//      delay(200); // attendre 2 seconde
//    }
//    
//  }







On utilise une routine d'interruption pour incrémenter ou décrémenter un compteur afin de modifier la vitesse de commutation des LED. Pour cela, on utilise deux boutons ainsi qu'un écran LCD pour nous indiquer la valeur du compteur.

Notre carte n'étant pas disponible au moment de nos tests, on a utilisé un ULN2803 qui est un microcontrôleur comportant 8 transistors. Ce composant ne supportant que 0.5 A, pour ces lampes de 7W il nous faut une tension suffisamment élevée pour qu'il fonctionne correctement. Nous avons donc alimenté en 42 V ce qui nous faisait environ 0.2A.




Le résultat pour 8/12 LED est comme sur cette vidéo :

https://youtu.be/F_GRZFYA8tY

Sur cette vidéo, on voit bien que la portée est plutôt grande (mur du fond à 30m), on voit aussi que l'on peut modifier la vitesse (ou plutôt le delay entre chaque commutation) , la plus adaptée pour un phare à mon goût se trouve être 168 ms.
On voit enfin que l'angle entre les LED est assez important.

5/ Perspective

Pour obtenir un phare à LED proche de la perfection, il y a deux possibilités :
-Rajouter des LED pour augmenter le rayon du phare et ainsi diviser l'angle entre les LED (le plus le meilleur)
-Mettre une seule LED sur un moteur à courant continu dont la vitesse de rotation de la LED correspondra à la vitesse de rotation du moteur (le plus ressemblant)

en piece jointe ;
un fichier qui permet de se poser les bonnes questions pour reguler le courant dans une led de 100W avec lentille de 14° mais pour PIC16F877. il va falloir modifier le programme pour passer en Arduino

chenot

#1
Apr 04, 2018, 10:58 am Last Edit: Apr 10, 2018, 03:07 pm by chenot
Pour un phare à LED à partir d'un moteur DC, le fonctionnement serait plutôt simple. Le moteur est directement connecté à la place d'une  LED pour faire varier la vitesse de rotation du moteur entre 60 tr/mini et 1 tr/min.

Voici un schéma ISIS correspondant à notre besoin et comportant une carte arduino :



Nous avons utilisé une carte arduino nano car nous avons besoin de programmer qu'une  seule PWM. Il ne reste donc qu'à programmer un code permettant de modifier le rapport cyclique de la PWM en appuyant sur les boutons poussoirs et ainsi modifier la vitesse de rotation de notre phare.

iutgeiisoissons

#2
Apr 05, 2018, 04:41 pm Last Edit: Apr 09, 2018, 03:25 pm by iutgeiisoissons
Effectivement, un moteur DC, c'est simple. Mais tourner 24h/24 avec ce type de moteur risque de tomber en panne tres rapidement à cause de l'usure des balais et du collecteur
Donc un moteur pas à pas est plus intéressant où un moteur BLDC.
Etant donné que la vitesse du phare est relativement lente entre 30 tr/min à 5tr/min et qu'il faut inverser la rotation de tous les 3 tours à cause du fil qui alimente la led de puissance, un moteur pas à pas fera l'affaire.

Mais 2 questions subsistent :

est ce qu'il vaut mieux avoir un moteur pas à pas plus gros et pas de reduteur ?
Lequel durera le plus longtemps ?      >:(  :o  :smiley-twist:    

exemple 28BYJ-48:
Le petit moteur pas à pas réducté de 64, avec un pas à 5,625° suivant suffirait.
Mais est qu'il durera dans le temps ce moteur ??????????


La vitesse avec une frequence de 600Hz correspondra à l'equation suivante :
Vitesse max =(5.625°/360°)*(600pas/s*60)/64=9 tour/min

Ce moteur a des phases avec une resistance de 200ohms donc sous 5V, le courant etabli est de 25mA.
Mais quel est le regime de start stop de ce moteur pour cette tension ? (couple en fonction du nombre de pas/s)
Difficile de trouver le datasheet malgré les nombreux utilisateurs de forums
http://tiptopboards.free.fr/arduino_forum/viewtopic.php?f=2&t=41
http://42bots.com/tutorials/28byj-48-stepper-motor-with-uln2003-driver-and-arduino-uno/
https://www.amazon.fr/4-Phase-Electrique-28BYJ-48-Commande-ULN2003/dp/B00DGNO6PI/ref=sr_1_1?s=hi&ie=UTF8&qid=1522907395&sr=1-1&keywords=moteur+pas+a+pas


Exemple moteur pas à pas 55SI-25DAYA

Vitesse max =(7.5°/360°)*(8 Hz*60)=10 tour/min


Il va falloir faire des essais avec ces 2 moteurs qui trainnent à l'IUT


un cours assez complet sur les moteurs pas à pas
http://sam.electroastro.pagesperso-orange.fr/dossiers/pasapas/moteurpas2.htm#alim

RClementZ

#3
Apr 10, 2018, 04:26 pm Last Edit: Apr 11, 2018, 10:25 am by RClementZ
Phare à LED version 2 : Programme de test

J'ai repris le concept de phare à LED en repartant de zéro et j'ai opté pour mettre une LED sur un moteur et de faire tourner ce dernier. Le but est de pouvoir contrôler la rotation de notre moteur.
Nous utilisons un Arduino MEGA 2560, un écran LCD, des boutons poussoirs, un ULN2803 et un moteur pas à pas 55SI-25DAYA.


Figure 1 : Ecran LCD


Figure 2 : Carte Arduino


Figure 3 : ULN2803


Figure 4 : Moteur 55SI-25DAYA
Le moteur est un moteur pas à pas unipolaire : le courant ne passe que dans un seul sens. Il possède 6 pins : 2 pour l'alimentation (1 de chaque cotés) et 4 autres pins afin d'alimenter ou non ses bobines. Cela va nous permettre aussi de changer son sens de rotation.


Dans cette première partie, je n'ai réalisé que la simulation avec un programme de test.






Programme de test
Code: [Select]
#include <TimerOne.h>
#include <LiquidCrystal.h>

#define HG 2
#define BG 3
#define HD 4
#define BD 5
#define BP_SENS 32
#define LED13 13
#define BP_incrementation 34
#define BP_decrementation 35

LiquidCrystal lcd(27, 28, 25, 24, 23, 22); // RS=12, Enable=11, D4=5, D5=4, D6= 3, D7=2

signed int etape=0;
unsigned int temps=0;   //temps entre deux pas
unsigned int flag;        // sens de reotation du moteur
unsigned int seconde_pas;  //temps par pas


Dans cette partie du programme, j'ai d'abord inclus les bibliothèques nécessaires. Vu que nous utilisons un écran LCD, nous devons intégrer la bibliothèque LiquidCrystal. De plus, nous utilisons une routine d'interruption, nous devons rajouter la bibliothèque TimerOne. Ensuite, j'ai défini mes entrées et sorties en fonction de mes besoins. Le moteur à 4 pins et chacune d'entre elle est reliée à l'Arduino. Elles sont représentées par HG (Haut Gauche), BG (Bas Gauche), HD (Haut Droite), et BD (Bas Droite) par rapport à la simulation.


Code: [Select]
void setup() {
  pinMode(HG,OUTPUT);
  pinMode(BG,OUTPUT);
  pinMode(HD,OUTPUT);
  pinMode(BD,OUTPUT);
  seconde_pas = 100;
  // programmation d'une interruption toutes les 1 millisecondes
  Timer1.initialize(1000);
  Timer1.attachInterrupt(timerIsr);
  lcd.begin(16, 2);
}


Nous faisons ici la partie setup du programme où nous déclarons le sens des broches de l'Arduino. Nous initialisons aussi la variable qui indique le nombre de seconde par pas. Le Timer1 est initialisé à 1 milliseconde. L'écran que nous utilisons est un écran 2 lignes 16 colonnes.



Code: [Select]
void timerIsr() { // fonction appelée lors de l'interruption 1ms
 temps++;

}


Ici nous incrémentons notre variable temps de 1 à chaque interruption. Elle nous servira pour définir la vitesse de rotation des étapes.


Code: [Select]
void pas(int etape) {
  switch(etape) {
    case 0: // 1000
    digitalWrite(HG,HIGH);
    digitalWrite(BG,LOW);
    digitalWrite(HD,LOW);
    digitalWrite(BD,LOW);
 //   delay(200);
    break;
    case 1: // 0010
    digitalWrite(HG,LOW);
    digitalWrite(BG,LOW);
    digitalWrite(HD,HIGH);
    digitalWrite(BD,LOW);
//    delay(200);
    break;
    case 2: // 0001
    digitalWrite(HG,LOW);
    digitalWrite(BG,LOW);
    digitalWrite(HD,LOW);
    digitalWrite(BD,HIGH);
 
    break;
    case 3: // 0100
    digitalWrite(HG,LOW);
    digitalWrite(BG,HIGH);
    digitalWrite(HD,LOW);
    digitalWrite(BD,LOW);
    break;
  }  
}


Notre fonction pas ici nous donne le séquencement des pins à alimenter. Elles sont alimentées en fonction de leur position et de la position du moteur. Le digitalWrite permet d'écrire une valeur sur la pin voulue (1 ou 0).


Code: [Select]


void pas_sens_1() {
  etape++;
  if (etape>3) etape = 0;
  pas(etape);
 }

void pas_sens_2() {
  etape--;
  if (etape<0) etape = 3;
  pas(etape);  
}


Nous avons ici 2 fonctions permettant la rotation du moteur. La première permet de tourner dans le sens horaire, la deuxième dans le sens antihoraire. En fonction de la rotation, soit la valeur de etape monte d'un cran, soit elle diminue. Quand la valeur dépasse 3 dans le sens horaire, on la remet à 0. Si elle tombe en dessous de 0 dans le sens antihoraire, elle remonte à 3 afin de perpétuer le cycle. Ensuite, on alimente la bobine en fonction de l'étape actuelle.

Code: [Select]
void loop() {

    lcd.setCursor(1,0);      //colonne, ligne
    lcd.print("etape : ");
    lcd.setCursor(9,0);
    lcd.print(etape);
    lcd.setCursor(1,1);
    lcd.print("sec/pas :");
    lcd.print(seconde_pas);
    lcd.print("     ");
      

    if(digitalRead(BP_incrementation)==1) { seconde_pas++; delay(50); }
    if(digitalRead(BP_decrementation)==1) { seconde_pas--; delay(50);}

    if(digitalRead(BP_SENS)==1){ flag=1;}
    else {flag = 2;}


     if (temps>seconde_pas) {
      if(flag == 1) {
        pas_sens_1();
      }
      else{
        pas_sens_2();
      }
        temps=0;
      }
}


La fonction principale du programme va nous permettre ici d'écrire sur l'écran LCD les valeurs voulues. Le lcd.setCursor nous permet de déplacer le curseur sur l'écran et le lcd.print d'écrire à l'endroit du curseur. Nous écrirons sur le LCD la valeur de l'étape actuelle ainsi que le nombre de secondes par pas.
Ensuite, nous avons l'utilisation des boutons : le BP_incrementation va permettre d'augmenter le nombre de secondes par pas. Le délai de 50ms va permettre de ne pas incrémenter trop rapidement.
Idem pour le BP_decrementation mais dans l'autre sens cette fois. Le BP_SENS va nous permettre de changer le sens de rotation. Quand le bouton sera sur 1, on ira dans le sens horaire, quand il sera sur 0 on ira dans l'autre sens. Enfin, si notre temps devient supérieur à la valeur de notre variable seconde_pas alors en fonction du flag (qui indique le sens de rotation), le moteur tournera dans le sens voulu.

Le programme complet :

Code: [Select]
// commande d'un moteur pas à pas unipolaire avec un ULN2803
// programmation des pas par interruption

#include <TimerOne.h>
#include <LiquidCrystal.h>

#define HG 2
#define BG 3
#define HD 4
#define BD 5
#define BP_SENS 32
#define LED13 13
#define BP_incrementation 34
#define BP_decrementation 35

LiquidCrystal lcd(27, 28, 25, 24, 23, 22); // RS=12, Enable=11, D4=5, D5=4, D6= 3, D7=2

signed int etape=0;
unsigned int temps=0;   //temps entre deux pas
unsigned int flag;        // sens de reotation du moteur
unsigned int seconde_pas;  //temps par pas

void setup() {
  pinMode(HG,OUTPUT);
  pinMode(BG,OUTPUT);
  pinMode(HD,OUTPUT);
  pinMode(BD,OUTPUT);
  seconde_pas = 100;
 // pas(etape);
  // programmation d'une interruption toutes les 1 millisecondes
  Timer1.initialize(1000);
  Timer1.attachInterrupt(timerIsr);
  lcd.begin(16, 2);
}


void timerIsr() { // fonction appelée lors de l'interruption 20ms
 temps++;

}


void pas(int etape) {
  switch(etape) {
    case 0: // 1000
    digitalWrite(HG,HIGH);
    digitalWrite(BG,LOW);
    digitalWrite(HD,LOW);
    digitalWrite(BD,LOW);
 //   delay(200);
    break;
    case 1: // 0010
    digitalWrite(HG,LOW);
    digitalWrite(BG,LOW);
    digitalWrite(HD,HIGH);
    digitalWrite(BD,LOW);
//    delay(200);
    break;
    case 2: // 0001
    digitalWrite(HG,LOW);
    digitalWrite(BG,LOW);
    digitalWrite(HD,LOW);
    digitalWrite(BD,HIGH);
 
    break;
    case 3: // 0100
    digitalWrite(HG,LOW);
    digitalWrite(BG,HIGH);
    digitalWrite(HD,LOW);
    digitalWrite(BD,LOW);
    break;
  }  
}

void pas_sens_1() {
  etape++;
//  delay(200);
  if (etape>3) etape = 0;
  pas(etape);
 }

void pas_sens_2() {
  etape--;
//  delay(200);
  if (etape<0) etape = 3;
  pas(etape);  
}



void loop() {

    lcd.setCursor(1,0);      //colonne, ligne
    lcd.print("etape : ");
    lcd.setCursor(9,0);
    lcd.print(etape);
    lcd.setCursor(1,1);
    lcd.print("sec/pas :");
    lcd.print(seconde_pas);
    lcd.print("     ");
      

    if(digitalRead(BP_incrementation)==1) { seconde_pas++; delay(50); }
    if(digitalRead(BP_decrementation)==1) { seconde_pas--; delay(50);}

    if(digitalRead(BP_SENS)==1){ flag=1;}
    else {flag = 2;}


     if (temps>seconde_pas) {
      if(flag == 1) {
        pas_sens_1();
      }
      else{
        pas_sens_2();
      }
        temps=0;
      }
}

RClementZ

#4
Apr 11, 2018, 09:04 am Last Edit: Apr 11, 2018, 09:07 am by RClementZ
Simulation

Nous avons simulé le programme ci-dessus sur ISIS.


Le schéma contient les éléments ci-dessous.


Le « motor stepper » représente notre moteur pas à pas unipolaire.

L'écran LCD que nous utilisons est un LM016L mais vous pouvez le remplacer par d'autres écrans. Les pins que nous avons définies ont été placé au bon endroit (heureusement). Nous avons trois boutons : 1 permettant de changer le sens de rotation et les deux autres permettent de changer le nombre de seconde par pas.


Simulation dans le sens antihoraire.


Etape 3 sens antihoraire.

Voici le fichier isis :
https://www.dropbox.com/s/xprq998phrn7w36/isis.DSN?dl=0

RClementZ

L'ULN


L'ULN est un petit composant électronique de Texas Instrument. Il est constitué de 8 transistor NPN. Si vous voulez de plus amples détails techniques, vous pouvez aller sur ce lien : http://www.ti.com/lit/ds/symlink/uln2803a.pdf .



Le but de ce post est seulement d'expliquer brièvement le fonctionnement de l'ULN et de le simuler « manuellement » (sans le composant) avec le moteur.  Le moteur est quant à lui constitué de d'une bobine par pin et de 4 diodes de roue libre en antiparallèle.

L'ULN avec le moteur.


ULN « à la main » plus moteur  

On peut voir sur la simulation ci-dessus que le moteur est relié à 4 transistors (1 par pin) et que ses 2 côtés sont bien alimentés en 12v. Les transistor et résistance de 10k représente l'ULN. Quand le signal arrive dans la base du transistor, ce dernier est alors inhibé et le courant peut aller à la masse ce qui permet d'activer le courant. Les diodes de roue libre sont représentées par les diodes D1, D2, D5, D6. Elles permettent de ne pas endommager le moteur lorsque la pin n'est plus alimentée. Elles sont reliées sur le 12v. Enfin, nous avons alimenté en 5v des led qui s'allument quand une bobine est allumée.
Cela permet de comprendre plus facilement le fonctionnement de l'ULN
Je vous joins le fichier isis.


Le programme final

Le programme final est quasiment identique au programme précédent à quelques exception près mais je vais quand même reprendre du début afin de vous montrer les changements effectués. Le but est d'automatiser le phare et surtout de ne pas abimé le câble d'alimentation de la LED. Il faut donc demander au moteur de changer de sens tous les x tours. Nous avons choisi 3 tours de moteur.


Code: [Select]
#include <TimerOne.h>
#include <LiquidCrystal.h>
#define HG 2
#define BG 3
#define HD 4
#define BD 5
#define LED13 13
#define BP_incrementation 31
#define BP_decrementation 32
LiquidCrystal lcd(27, 28, 25, 24, 23, 22); // RS=12, Enable=11, D4=5, D5=4, D6= 3, D7=2
signed int etape=0;
unsigned int temps=0;   //temps entre deux pas
unsigned int flag=1;        // sens de rotation du moteur
unsigned int seconde_pas;  //temps par pas
unsigned int tour=0;        //Nombre de fois que les 4 étapes sont faites


Très peu de choses ont changé dans cette partie du programme à part la définition des pins qui ont été changé en fonction de notre câblage du moteur et de la où était branché nos boutons. Le bouton BP_SENS est en commentaire car nous ne nous en servons plus dans ce programme.

void setup() {
 pinMode(HG,OUTPUT);
 pinMode(BG,OUTPUT);
 pinMode(HD,OUTPUT);
 pinMode(BD,OUTPUT);
 seconde_pas = 100;
 // programmation d'une interruption toutes les 1 millisecondes
 Timer1.initialize(1000);
 Timer1.attachInterrupt(timerIsr);
 lcd.begin(16, 2);
}

Rien n'a changé dans le setup. Nous avons toujours nos pins en sorties, l'initialisation de notre variable seconde_pas à 100 (que vous pouvez changer à votre guise), le timer1 de 1 milliseconde et l'écran LCD.

Code: [Select]
void timerIsr() { // fonction appelée lors de l'interruption 20ms
 temps++;

}


La routine d'interruption reste la même : elle incrémente la variable temps.

Code: [Select]
void pas(int etape) {
  switch(etape) {
    case 0: // 1000
    digitalWrite(HG,LOW);
    digitalWrite(BG,LOW);
    digitalWrite(HD,LOW);
    digitalWrite(BD,HIGH);
    break;
    case 1: // 0010
    digitalWrite(HG,HIGH);
    digitalWrite(BG,LOW);
    digitalWrite(HD,LOW);
    digitalWrite(BD,LOW);
    break;
    case 2: // 0001
    digitalWrite(HG,LOW);
    digitalWrite(BG,LOW);
    digitalWrite(HD,HIGH);
    digitalWrite(BD,LOW);
 
    break;
    case 3: // 0100
    digitalWrite(HG,LOW);
    digitalWrite(BG,HIGH);
    digitalWrite(HD,LOW);
    digitalWrite(BD,LOW);
    if(flag==1) {tour++;}
    if(flag==2) {tour--;}
    break;
  }  
}


Le changement ici est que l'activation des pins a changé d'ordre afin de permettre à notre moteur de tourner (car des pins ont été inversées avec d'autres). Vous devez mettre l'ordre qui correspond à votre câblage. Dans le dernier case, Nous incrémentons une variable tour : elle permet de compter le nombre de fois que le tour des 4 étapes. Cela va nous permettre de calculer le nombre qu'il faut pour faire 3tours dans un sens.

Code: [Select]
void pas_sens_1() {
  etape++;
  if (etape>3) etape = 0;
  pas(etape);
 }

void pas_sens_2() {
  etape--;
  if (etape<0) etape = 3;
  pas(etape);  
}


Rien à changer dans nos fonctions de sens du moteur. A chaque fois qu'on rentre dans une fonction, ou incrémente ou décrémente la variable état pour passer à la prochaine commande.


 
Code: [Select]
 lcd.setCursor(1,0);      //colonne, ligne
    lcd.print("etape : ");
    lcd.print(etape);
    lcd.print("tour");
    lcd.print(tour);
    lcd.print("  ");
    lcd.setCursor(1,1);
    lcd.print("sec/pas :");
    lcd.print(seconde_pas);
    lcd.print("     ");

Ici, nous gérons notre affichage. Nous avons juste retiré l'affichage du temps et nous l'avons remplacé par l'affichage de la variable tour.

    if(digitalRead(BP_incrementation)==1) { seconde_pas++;  }
    if(digitalRead(BP_decrementation)==1) { seconde_pas--;  }
    if(seconde_pas>=10001) { seconde_pas = 10000;}
    if(seconde_pas<=0) { seconde_pas = 1;}
    if(tour==36 && flag ==1){ flag=2;}
    if(tour==0 && flag ==2){ flag=1;}


Ici nous gérons donc les 2 boutons restants : l'incrémentation et la décrémentation. On limite aussi les secondes par pas : on limite le maximum a 10 secondes par pas et le minimum à 1ms par pas. Les valeurs sont arbitraires et vous pouvez choisir celle que vous voulez. Le plus important est ce qui suit : le choix du flag. Pour rappel, le flag permet de déterminer le sens de rotation. On demande à savoir si le nombre de tour est égale à 36 et si le flag est égal à 1. C'est parti pour un peu de mathématiques : 1 tour étape = 4 étapes. 4 étapes 7.5°*4.   1 étape = 7.5°   1 tour moteur = 360° donc 360°/7.5° = 48 étapes. 48 étapes = 12 tours. Pour faire 3 tours moteur entier, on doit donc avoir 36 tours étapes. Le flag permet de dire d'inverser le sens de rotation quand ma valeur est de 36. Ensuite, on change de sens et on décrémente la valeur de tour pour atteindre 0.
 




Code: [Select]
if (temps>seconde_pas) {
      if(flag == 1) {
        pas_sens_1();
      }
      else{
        pas_sens_2();
      }
        temps=0;
      }
}


Dans ce dernier point, rien n'a changé. En fonction du flag, on choisi le sens de rotation.

Le code au complet est disponible ci-dessous.

https://www.dropbox.com/s/w3g83a3gqdacc72/ISIS.rar?dl=0

Vous pouvez voir le système en fonctionnement sur youtube grâce au lien suivant :
https://youtu.be/AsjHqG07YWI

iutgeiisoissons

#6
Apr 16, 2018, 08:31 am Last Edit: Apr 16, 2018, 08:34 am by iutgeiisoissons
Maintenant que la partie tournante est réalisée avec le moteur pas à pas précèdent mais avec une led de 10W qui a une focale de 7°,
Il est possible de mettre une led 100W qui doit avoir un ventilateur, 100W (matrice de 10*10 led blanche 30V) qui est vendu souvent avec une lentille de 60°, donc il faudra changer celle -ci. Le driver permet de convertir le 220V AC en régulation de courant à 3A.


Si le ventilateur tombe en panne, le led est détruite en à peine 1 minute. Par conséquent, une surveillance de la température du dissipateur peut être effectuée par l'Arduino pour couper l'alimentation du driver par un relais.
De plus, une LDR permet de couper l'alimentation lorsqu'il fait en dessous de 50 lux de lumière.


L'article suivant précise que  lorsque la température va monter sa tension de seuil va diminuer. D'où la régulation en courant.
https://www.fichier-pdf.fr/2016/10/21/led-100watt-regulation-revue-3ei/

Pour faire varier l'intensité lumineuse de la led, il serait possible aussi de réguler le courant dans la led par l'intermédiaire d'un hacheur et l'Arduino.
Ce sujet a déjà été effectué à l'IUT mais avec un PIC
Donc, il va falloir transformer le programme du compilateur PCW pour micro chip 16F877 en Arduino

Arduino devrait s'inspirer de Pic-wizard de PCW pour faire la configuration des cartes qui deviennent de plus en plus nombreuses avec des possibilités différentes


Voici le schéma ISIS de cette commande de led
Téléchargeable sur ce lien
https://drive.google.com/open?id=1KRbiZj7j5l_u9AKhZ3LkS8kf4gmTMB9_


Attention, l'utilisation de graphe mesurant la tension moyenne et le courant prend énormément de mémoire 27Mega à la place de 167k mais cela permet de vérifier le bon fonctionnement de la régulation .

le Programme pour PIC16F877 en attaché à transformer en arduino




La regulation de la led ressemble à la regulation du batterie.
Voir le sujet suivant
https://forum.arduino.cc/index.php?topic=538070.0



Go Up