Grue à bec de Canard – partie 4

Fichier hébergé par Archive-Host.com

Fichier hébergé par Archive-Host.com

Fichier hébergé par Archive-Host.com

Pour interagir avec l’Arduino depuis le PC, Yves a écrit deux codes processing


// Slider 1
 
// un slider pour commander la vitesse d'un moteur 
 // importer les librairies nécessaires
import processing.serial.*; // présente par défaut
import controlP5.*; // il faut l'installer

ControlP5 controlP5;
Serial serial;
  
int prefixe_moteur = 121 ; 
// ce prefixe indique que la commande qui va suivre concerne le moteur
 
void setup() {
  // On dessine la fenêtre de l'interface graphique
  size(400,350);
   
  // Le programme affiche dans la fenêtre de debuggage
  // de processing, en bas d'écran la liste des ports
  println("Voici la liste des ports :");
  println(Serial.list());
   
  // ici on a choisi le port 0
  // il faut peut-être essayer une autre
  // valeur de la liste en cas de pb
   
  int numero_port_serie = 0;
   
  print("Le numero de port est : ");
  println(numero_port_serie);
   
  String port = Serial.list()[numero_port_serie];
   
  print("Le port est : " );
  println(port);
 
  serial = new Serial(this, port, 9600); 
// attention a mettre la même vitesse coté Dfrduino

  controlP5 = new ControlP5(this); 
 
  // Créer un  slider horizontal
 
  //("Nom du Slider", min,max, pos de depart, xpos,ypos, largeur,hauteur);
  controlP5.addSlider("MOTEUR", -50,50, 0, 100,150, 200,20);
   
  // Configure les propriétés du Slider
  Slider s2 = (Slider)controlP5.controller("MOTEUR");
  s2.setSliderMode(Slider.FLEXIBLE);
  s2.setNumberOfTickMarks(11);
  s2.showTickMarks(true);
  s2.snapToTickMarks(false);
}
// Dessine les objets choisis
void draw() {
  background(100); // 100 : fond gris
} 

// Dans cette méthode// on récupère la valeur 
// renvoyée par le slider moteur2// et on l'envoie à l'Arduino
 
void MOTEUR(float valeur_slider) {
   
  int sens = 1; // marche avant moteur
   
  // Récupérer la valeur envoyée par le slider entre -50 et 50
   
  if (valeur_slider < 0) {
      sens= 0 ; // marche arriere
      valeur_slider = - valeur_slider;
  }    
   
  int vitesse = round(valeur_slider);
   
  // envoyer cette valeur à l'Arduino 
  
  serial.write (prefixe_moteur);
   
  serial.write (sens);
   
  serial.write(vitesse); 
   
 }

// Slider 1moteurs     
// un slider pour commander la vitesse des moteurs 
 // importer les librairies nécessaires
import processing.serial.*; // présente par défaut
import controlP5.*; // il faut l'installer

ControlP5 controlP5;
Toggle t1;
Toggle t2;
Toggle t3;
Toggle t4;
Serial serial;
 
int prefixe_moteurs = 111 ; 
// ce prefixe indique que la commande qui va suivre concerne les moteurs
  
void setup() {
  // On dessine la fenêtre de l'interface graphique
  size(550,350);
  
  // Le programme affiche dans la fenêtre de debuggage
  // de processing, en bas d'écran la liste des ports
  println("Voici la liste des ports :");
  println(Serial.list());
   
  // ici on a choisi le port 1
  // il faut peut-être essayer une autre
  // valeur de la liste en cas de pb
   
  int numero_port_serie = 1;   
  print("Le numero de port est : ");
  println(numero_port_serie);   
  String port = Serial.list()[numero_port_serie];   
  print("Le port est : " );
  println(port);
 
  serial = new Serial(this, port, 9600);
  controlP5 = new ControlP5(this); 
 
 // Créer un premier toggle  
  t1 = controlP5.addToggle("toggleLED1",false,10,10,100,100); 
  // Configure les propriétés du Toggle  
  // méthodes propres à l'objet Toggle
  t1.setMode(ControlP5.DEFAULT); // fixe le mode de fonctionnement du Toggle : ControlP5.DEFAULT ou ControlP5.SWITCH
  // setImages(PImage theImageDefault,PImage theImageOver, PImage theImageActive,PImage theImageHighlight)
  // les images doivent etre de la meme taille que bouton, dans rép prog, type .jpg .png ..
  // un toggle n'utilise que image Default et Active
  t1.setImages(loadImage("imageDefault.png"),loadImage("imageDefault.png"), loadImage("imageActive.png"),loadImage("imageDefault.png"));
 
 // Créer un deuxième toggle  
  t2 = controlP5.addToggle("toggleLED2",false,150,10,100,100);  
  // Configure les propriétés du Toggle 
  // méthodes propres à l'objet Toggle
  t2.setMode(ControlP5.DEFAULT); // fixe le mode de fonctionnement du Toggle : ControlP5.DEFAULT ou ControlP5.SWITCH

  // setImages(PImage theImageDefault,PImage theImageOver, PImage theImageActive,PImage theImageHighlight)
  // les images doivent etre de la meme taille que bouton, dans rép prog, type .jpg .png ..
  // un toggle n'utilise que image Default et Active
  t2.setImages(loadImage("imageDefault.png"),loadImage("imageDefault.png"), loadImage("imageActive.png"),loadImage("imageDefault.png"));
 
 // Créer un troisième toggle
 t3 = controlP5.addToggle("toggleLED3",false,290,10,100,100);  
  // Configure les propriétés du Toggle  
  // méthodes propres à l'objet Toggle
  t3.setMode(ControlP5.DEFAULT); // fixe le mode de fonctionnement du Toggle : ControlP5.DEFAULT ou ControlP5.SWITCH
  // setImages(PImage theImageDefault,PImage theImageOver, PImage theImageActive,PImage theImageHighlight)
  // les images doivent etre de la meme taille que bouton, dans rép prog, type .jpg .png ..
  // un toggle n'utilise que image Default et Active
  t3.setImages(loadImage("imageDefault.png"),loadImage("imageDefault.png"), loadImage("imageActive.png"),loadImage("imageDefault.png"));
 
 // Créer un quatrième toggle
 t4 = controlP5.addToggle("toggleLED4",false,430,10,100,100);  
  // Configure les propriétés du Toggle  
  // méthodes propres à l'objet Toggle
  t4.setMode(ControlP5.DEFAULT); // fixe le mode de fonctionnement du Toggle : ControlP5.DEFAULT ou ControlP5.SWITCH
  // setImages(PImage theImageDefault,PImage theImageOver, PImage theImageActive,PImage theImageHighlight)
  // les images doivent etre de la meme taille que bouton, dans rép prog, type .jpg .png ..
  // un toggle n'utilise que image Default et Active
  t4.setImages(loadImage("imageDefault.png"),loadImage("imageDefault.png"), loadImage("imageActive.png"),loadImage("imageDefault.png"));
 
  // Créer un premier slider horizontal
  //("Nom du Slider", min,max, pos de depart, xpos,ypos, largeur,hauteur);
  controlP5.addSlider("MOTEURS", -50,50, 0, 100,200, 200,20);
   
  // Configure les propriétés du Slider
  Slider s1 = (Slider)controlP5.controller("MOTEURS");
  s1.setSliderMode(Slider.FLEXIBLE);
  s1.setNumberOfTickMarks(11);
  s1.showTickMarks(true);
  s1.snapToTickMarks(false);
 
 } 
  
// Dessine les objets choisis
void draw() {
  background(155); // 100 : fond gris
  fill(0);
  PFont maTypo=loadFont("ArialMT-14.vlw");
  textFont(maTypo,14);
   text ("Pelle",40,140);
   text ("Rotation",180,140);
   text ("Charge",320,140);
   text ("Flèche",460,140);
}
// Dans cette méthode
// on récupère la valeur 
// renvoyée par le slider moteurs     
// et on l'envoie à l'Arduino
 
void MOTEURS(float valeur_slider) {   
  int sens = 1; // marche avant moteur  
  // Récupérer la valeur envoyée par le slider entre -50 et 50  
  if (valeur_slider < 0) {
      sens= 0 ; // marche arriere
      valeur_slider = - valeur_slider;
  }      
  int vitesse = round(valeur_slider);// envoyer cette valeur à l'Arduino  
  serial.write (prefixe_moteurs);   
  serial.write (sens); 
  serial.write(vitesse);   
} 
void toggleLED1(int theValue) { // fonction évènement Toggle de meme nom - reçoit la valeur
        println("Evènement Toggle LED1 avec valeur = "+t1.getState());

        if (t1.getState()==true)serial.write(101); 
        // envoie caractère H sur port Série si bouton toggle état 1
        if (t1.getState()==false)serial.write(100); 
        // envoie caractère L sur port Série si bouton toggle état 0
}
void toggleLED2(int theValue) { // fonction évènement Toggle de meme nom - reçoit la valeur
        println("Evènement Toggle LED2 avec valeur = "+t2.getState());

        if (t2.getState()==true)serial.write(201); 
        // envoie caractère H sur port Série si bouton toggle état 1
        if (t2.getState()==false)serial.write(200); 
        // envoie caractère L sur port Série si bouton toggle état 0
}
void toggleLED3(int theValue) { // fonction évènement Toggle de meme nom - reçoit la valeur
        println("Evènement Toggle LED3 avec valeur = "+t3.getState());

        if (t3.getState()==true)serial.write(231); 
        // envoie caractère H sur port Série si bouton toggle état 1
        if (t3.getState()==false)serial.write(230); 
        // envoie caractère L sur port Série si bouton toggle état 0
}
void toggleLED4(int theValue) { // fonction évènement Toggle de meme nom - reçoit la valeur
        println("Evènement Toggle LED4 avec valeur = "+t4.getState());

        if (t4.getState()==true)serial.write(241); 
        // envoie caractère H sur port Série si bouton toggle état 1
        if (t4.getState()==false)serial.write(240); 
        // envoie caractère L sur port Série si bouton toggle état 0
}

Enfin sur chaque carte DFrduino, les codes sont ci-dessous :


/*
 * Slider 1 moteur
 * 4 relais 
 * Dfrduino
*/  
// Broches 2,7,8,10 : connectée relais
// --- Déclaration des constantes des broches E/S numériques ---

int PIN_ONOFF[4] = {2,7,8,10}; // Constante pour les broche 2,7,8,10;
  
int Pin_sens = 4; // le sens du moteur est commandé par la Pin 4 
int Pin_pwm = 5 ; // la vitesse du moteur est commandée par la Pin 5 
int pwm = 255;  // la largeur d'impulsion pwm (0-255) 

byte donnee_serie = 0;
 
void setup() {
   // Ouvrir la liaison série
   Serial.begin(9600);  
  // ------- Broches en sorties numériques -------  
  for(int i=0; i<4; i++)
  {
     pinMode (PIN_ONOFF[i],OUTPUT); // Broche LED configurée en sortie
  }  
} 
void loop() {
   
  int sens=0;
  int vitesse= 0;
 // int moteur=0;
   
   // Est-ce qu'il y a qq chose à lire sur l'interface série ?
    
   if (Serial.available()) {
     donnee_serie = Serial.read();
     
     if (donnee_serie==101) { // si Octet reçu est le H (101 = Marche / Etat Haut)
         digitalWrite(PIN_ONOFF[0], HIGH); // allume la LED
     }
     if (donnee_serie==100) { // si octet reçu est le L (100 = Arret / Etat Bas)
         digitalWrite(PIN_ONOFF[0], LOW); // éteint la LED
     }     
    if (donnee_serie==201) { // si Octet reçu est le H (101 = Marche / Etat Haut)
         digitalWrite(PIN_ONOFF[1], HIGH); // allume la LED
     }
     if (donnee_serie==200) { // si octet reçu est le L (100 = Arret / Etat Bas)
         digitalWrite(PIN_ONOFF[1], LOW); // éteint la LED
     } 

     if (donnee_serie==231) { // si Octet reçu est le H (101 = Marche / Etat Haut)

         digitalWrite(PIN_ONOFF[2], HIGH); // allume la LED
     }
     if (donnee_serie==230) { // si octet reçu est le L (100 = Arret / Etat Bas)
         digitalWrite(PIN_ONOFF[2], LOW); // éteint la LED
     }
        if (donnee_serie==241) { // si Octet reçu est le H (101 = Marche / Etat Haut)
         digitalWrite(PIN_ONOFF[3], HIGH); // allume la LED
     }
     if (donnee_serie==240) { // si octet reçu est le L (100 = Arret / Etat Bas)
         digitalWrite(PIN_ONOFF[3], LOW); // éteint la LED
     } 
	if (donnee_serie == 111) {       
          sens=lire_suivant(); // sens
         vitesse=lire_suivant(); // vitesse
         controle(sens,vitesse);                 
     }         
   } 
}           
 
int lire_suivant() {
while (1) { 
 
 if (Serial.available() ) {
      return (Serial.read());
 }
} // while
}
// la procédure de contrôle des moteurs
 
void controle (int sens, int v)         
// m : 1 ou 2 pour moteur 1 ou moteur 2, 
// sens : 1 ou 0 (avant ou arrière)
// v : vitesse de 0 à 50, 
{
        int pwm;
        pwm = map(v, 0,50, 0,255); 
// ramener vitesse à l'intervalle 0 255
        digitalWrite(Pin_sens,sens);  // fixer sens
        analogWrite (Pin_pwm,pwm);    // fixer vitesse
                              
 
}


/*
 * Slider1-2 moteurs
 * deux moteurs
 * Dfrduino
*/  
int tab_Pin_sens = 4 ; // le sens du moteur est commandé par la Pin 4 
int tab_Pin_pwm  = 5 ; // la vitesse du moteur est commandée par la Pin 5 

int tab_Pin_sens2 = 7 ; // le sens du moteur est commandé par la Pin 7
int tab_Pin_pwm2  = 6 ; // la vitesse du moteur est commandée par la Pin 6 

int pwm = 255;  // la largeur d'impulsion pwm (0-255) 
byte donnee_serie = 0;
 
void setup() {
   // Ouvrir la liaison série
   Serial.begin(9600);
} 
void loop() {   
  int sens=0;
  int vitesse= 0;  
   // Est-ce qu'il y a qq chose à lire sur l'interface série ?   
   if (Serial.available()) {
     donnee_serie = Serial.read();
     if (donnee_serie == 121) {       
         sens=lire_suivant(); // sens
         vitesse=lire_suivant(); // vitesse
         controle(sens,vitesse);                  
     }   // 121                         
     } // 1er serial available
} // loop   

int lire_suivant() {
while (1) {  
 if (Serial.available() ) {
      return (Serial.read());
 }
} // while
}

// la procédure de contrôle des moteurs 
void controle (int sens, int v)         
// sens : 1 ou 0 (avant ou arrière)
// v : vitesse de 0 à 50, 
{
        int pwm;
        pwm = map(v, 0,50, 0,255); 
// ramener vitesse à l'intervalle 0 255
         digitalWrite(tab_Pin_sens,sens);  // fixer sens moteur 1
         digitalWrite(tab_Pin_sens2,sens); // fixer sens moteur 2

         analogWrite (tab_Pin_pwm,pwm);    // fixer vitesse moteur 1
         analogWrite (tab_Pin_pwm2,pwm);   // fixer vitesse moteur 2
}

Grue à bec de canard – partie 1

Yves s’est inspiré d’un modèle de grue rencontré en voyage pour monter un modèle meccano.

grue à bec de canard

meccano arduino grue

Le modèle est très complet avec 6 moteurs commandant les différents mouvements. Il utilise deux DFRduino Roméo, un Shield Xbee pour pouvoir être commandé sans fil, un shield 4 relais. Une interface processing détaillée plus loin permet de commander les 4 mouvements à la souris, à partir d’un PC.

Les 4 moteurs de mouvements sont alimentés par deux batteries au plomb de 6V en série qui font office de contre-poids pour la flèche (boîte en parallélépipède en bout de flèche) et les deux moteurs couplés de roulement le sont par une batterie de 12V placée en arrière du châssis au niveau des moteurs.

Les cartes électroniques sont alimentées directement en 12V par les batteries reliées aux différents moteurs

Horloge meccano-elec

Horloge en meccano elec

Horloge meccano elec

Voici une petite horloge commandée par un DFRduino Romeo mais on pourrait faire la même chose avec un arduino et un mosfet ou un arduino et un shield moteur ou un module contrôleur moteur.

Le programme est très simple, il consiste juste à alimenter à intervalles réguliers une bobine meccano elec. Cette bobine comporte un noyau cylindrique fendu qui entraîne une ancre. L’ancre met en mouvement une roue d’échappement.

On divise ensuite la vitesse de cette roue d’échappement par 5 (19/95) puis par 57 (vis sans fin / 57 dents) et on obtient l’axe des minutes. Pour avoir l’axe des heures, on divise par 3 puis par 4. Quand la bobine n’est plus alimentée, le noyau revient à sa position initiale sous l’effet d’un contre-poids placé en extrémité de l’ancre.

Il est préférable d’utiliser une alim variable pour ajuster précisément la tension d’entrée (ici on a utilisé 13 v en entrée).

Comme pour toutes les horloges il faut faire la chasse aux frottements, au points durs, au jeux insuffisants ou excessifs, aux mauvais alignements, aux tringles tordues … pour obtenir un bon fonctionnement.


//Horloge pour  DFRDuino Romeo V1.1
 
// Partie déclarations initiales
 
int V_M1 = 5; // Pin 5 controle de la vitesse de la sortie moteur M1
 
 
void alim_bobine(int t)
{
analogWrite (V_M1,255);
delay(t);
analogWrite (V_M1,0);
}
 
 
void attente(int t)
{
delay(t);
}
 
// Partie setup()
 
void setup() // executée une seule fois
{
pinMode(V_M1, OUTPUT); 
}
 
// Partie loop()
 
void loop() // executée en boucle
{
  
alim_bobine(200);

attente(590);
 
}

Horloge meccano elec

Arduino Uno et moteurs (partie 4)

On veut utiliser un moteur courant continu avec un Arduino Uno et on n’a pas de contrôleur moteur…

La meilleure solution que je connaisse est celle-ci : http://atelierjcm.com/arduino/arduino-et-mofset/

Cela permet d’entraîner même un gros moteur et de faire varier sa vitesse. Par contre on ne sait pas avec ce simple montage inverser le sens de rotation.

Attention, la solution Mosfet est une solution basique qui fonctionne bien mais elle n’a pas toutes les fonctionnalités d’un vrai contrôleur moteur. Pour aller plus loin je vous recommande la lecture de cet article vraiment très complet.

Une autre piste intéressante est celle des relais. Voir par exemple http://atelierjcm.com/arduino/shield-relais-partie-1/

Enfin si vous utilisez votre Uno essentiellement pour commander des moteurs, il faut aussi jeter un coup d’oeil aux excellentes cartes Romeo de DFRobot qui possèdent deux sorties moteurs intégrées et aussi une connectique très pratique pour connecter boutons, capteurs et même modules sans-fil Xbee.

Arduino Uno et moteurs (partie 3)

Cette troisième partie n’est pas autre chose que le rassemblement des deux parties précédentes. On utilise deux contrôleurs moteur, un pour le moteur pas à pas et un autre pour le moteur à courant continu. (on aurait d’ailleurs de quoi alimenter un deuxième moteur de ce type).

Avec ce type de montage on peut envisager, par exemple, de construire un ascenseur (moteur pas à pas) avec la porte qui s’ouvre et se ferme (moteur courant continu).

Si on fait le point sur les différentes alimentations électriques :

– la carte Arduino est alimentée par le port USB qui la relie au PC

– on a une alim 6v qui alimente les connecteurs VD de chaque contrôleur (alimentation de la partie logique de la carte)

– on a une alim 12v qui alimente les connecteurs VS de chaque contrôleur (alimentation des moteurs eux-mêmes)

– le GND de l’arduino, les – des deux alim précédentes, les GND des contrôleurs sont reliés entre eux.


/*
 Controle moteur pas à pas

 Ok pour Uno + controleur moteur DF-MD V1.3

 L298 M1 : vert (-) rouge, M2 : jaune (-), bleu
 
 Avec un deuxième controleur, controle d'un moteur 
 courant continu

 */

// moteur pas à pas//////////////////

#include <Stepper.h>

#define nb_pas_tour 200     // nombre de pas pour un tour
#define M1 8
#define M2  12


int E1=9;  // pin pwm
int E2=10; // pin pwm

// Initialisation de la librairie stepper

Stepper myStepper(nb_pas_tour, M1,M2); 

// moteur courant continu ////////////////

int EE1 = 4 ;
int MM1 = 5 ;

void marche(int a)          
{
  analogWrite (MM1,a);      
  digitalWrite(EE1,HIGH);  
} 

void arret(int a)          
{     
  digitalWrite(EE1,LOW); 
  delay(a); 
} 

//////////////////////////////////////////

void setup() {
  

  pinMode (E1, OUTPUT);
  pinMode (E2,OUTPUT);
  
  pinMode (EE1,OUTPUT);
  pinMode (MM1,OUTPUT);
  
  digitalWrite(E1,HIGH);
  digitalWrite(E2, HIGH);
  digitalWrite(EE1, HIGH);

}

void loop() {
  
  // moteur pas à pas ////////////
  
  // Fixer vitesse à 3 
  myStepper.setSpeed(3);
  
  // avancer de 100 pas
  myStepper.step(100);
  
  // attendre 2 secondes
  delay(2000);

  // Fixer vitesse à 60 
  myStepper.setSpeed(60);
  
  // reculer de 100 pas
  myStepper.step(-100);
  
  // attendre 2 secondes
  delay(2000); 
  
  // moteur courant continu /////////////
  
    marche(160); // en avant vitesse reduite
    
    delay(2000); //attendre 3 secondes
    
    marche(255); // en avant vitesse maxi
    
    delay(2000);
    
    arret(5000); // arret pendant 5 secondes
    
    marche(-160); // on part en marche arrière vitesse réduite
     
    delay(3000);
    
    marche(-255); // marche arrière vitesse maxi
     
    delay(2000);
    
    arret(3000); // arret pendant 5 secondes 
  

}

Arduino Uno et moteurs (partie 2)

On va utiliser un montage similaire au précédent mais, cette fois-ci, on va utiliser les deux sorties moteurs du contrôleur. Le type de moteur n’est plus le même, c’est un moteur pas à pas.


/*
 Controle moteur pas à pas

 Ok pour Uno + controleur moteur DF-MD V1.3  L298 

 On connecte un moteur pas à pas 4 fils sur 
 les sorties M1 et M2

 M1 : vert (-) rouge, M2 : jaune (-), bleu

 */


#include <Stepper.h>

#define nb_pas_tour 200     // nombre de pas pour un tour
#define M1  8
#define M2 12


int E1=9;  // pin pwm
int E2=10; // pin pwm

// Initialisation de la librairie stepper

Stepper myStepper(nb_pas_tour, M1,M2); 

void setup() {
  

  pinMode (E1, OUTPUT);
  pinMode (E2,OUTPUT);
  
  digitalWrite(E1,HIGH);
  digitalWrite(E2, HIGH);

}

void loop() {
  
  // Fixer vitesse à 3 
  myStepper.setSpeed(3);
  
  // avancer de 100 pas
  myStepper.step(100);
  
  // attendre 2 secondes
  delay(2000);

  // Fixer vitesse à 60 
  myStepper.setSpeed(60);
  
  // reculer de 100 pas
  myStepper.step(-100);
  
  // attendre 2 secondes
  delay(2000); 

}

Arduino Uno et moteurs (partie 1)

L’Arduino Uno n’est pas conçu pour alimenter à lui tout seul des moteurs. La raison est que l’intensité en sortie disponible pour une pin est de l’ordre de 20 mA et ça ne fait vraiment pas beaucoup pour alimenter un petit moteur électrique.

Mais, heureusement, il y a de très nombreuses solutions pour compléter l’Arduino et le faire piloter toutes sortes de moteurs.

En voici une première : utiliser un module de contrôle moteur tel le module DF-MD 1.3 de DFRobot (Ref DRI0002). Ce module ajoute 2 sorties moteurs à la carte Uno.

Fichier hébergé par Archive-Host.com

Voilà un petit programme abondamment commenté qui commande un moteur courant continu 12 volts en faisant varier sa vitesse et son sens.


// programme pour Arduino UNO + L298 Dfrobot DF-MD V-1.3
// controle vitesse et sens d'un moteur à courant continu


int E1 = 4;     // enable : interrupteur marche/arret

int M1 = 5;    //  controle vitesse et sens avec pwm


// A T T E N T I O N
// Première chose à faire : retirer le cavalier VD=VS du
// controleur moteur et ne jamais le remettre 
// S'il est mis cela veut dire que la carte n'a pas besoin 
// de sa propre alimentation, 
// qu'elle peut se servir de l'alimentation du moteur 
// Il est vraiment préférable de séparer alim moteur et alim
// logique de la carte.
// j'ai grillé un module pour avoir ignoré ce conseil...


// Alim de la carte Arduino : par ex par le port USB

// Alim du controleur moteur VD : par une alim 5v ;
// VD est le +, GND le moins

// Alim du moteur VS : par une alim 12v ou un peu plus 
// (le controleur provoque
// une chute de tension d'environ 2v ;
// si on veut 12v en sortie, il faut mieux 14v en entrée). 
// VS est le +, GND le moins

// Les masses des deux alim carte controleur et moteur 
// sont reliées sur la carte controleur (GND)
// La masse de la carte Arduino est aussi reliée aux masses
// précédentes

// Connexions logiques : 

// Arduino Pin 4 reliée à E1 
// C'est un interrupteur de mise en marche du moteur
// a l'état haut le moteur est alimenté
// à l'état bas il est arreté


// Arduino Pin 5 reliée à M1 
// la pin 5 peut generer des signaux pwm 
// elle est repérée par un signe ~ sur l'Arduino
// elle  va permettre de faire varier la vitesse du moteur
// mais aussi le sens de rotation




void marche(int a)          
{
  analogWrite (M1,a);      
  digitalWrite(E1,HIGH);  
} 

void arret(int a)          
{     
  digitalWrite(E1,LOW); 
  delay(a); 
} 


void setup() // executée une seule fois
{
    pinMode(E1, OUTPUT); 
    pinMode(M1, OUTPUT);     
    
}


void loop() // executée en boucle
{
  
          
    marche(150); // en avant vitesse reduite
    
    delay(3000); //attendre 3 secondes
    
    marche(255); // en avant vitesse maxi
    
    delay(3000);
    
    arret(5000); // arret pendant 5 secondes
    
    marche(-150); // on part en marche arrière vitesse réduite
     
    delay(3000);
    
    marche(-255); // marche arrière vitesse maxi
     
    delay(3000);
    
    arret(5000); // arret pendant 5 secondes
       
}

Shield relais (partie 2)

Dans la partie précédente, si l’on remplace l’ampoule par un petit moteur, le montage et le programme fonctionnent : le moteur se met en marche puis s’arrête. Ce montage fonctionne aussi très bien avec une carte Arduino Uno complétée par le shield relais. Par contre, pas de possibilité de régler la vitesse ou le sens de rotation du moteur sans équipement complémentaire.

Pour arriver à fixer à volonté vitesse et sens de rotation, on va utiliser comme alimentation non pas un boîtier de piles qui fournit une tension fixe mais la sortie M1 du DFRduino ; en effet, on sait qu’il est possible de commander la vitesse et le sens d’un moteur à courant continu à partir de cette sortie. Cette sortie sera ensuite, grâce aux relais, aiguillée vers le moteur à animer.

Tant qu’à faire, on a ici branché 4 moteurs, tous connectés à cette même sortie M1. Voici le schéma de principe réalisé avec Fritzing (l’agrandir si nécessaire pour mieux le visualiser). Le shield qui se pose au-dessus du DFRduino n’est pas représenté sur le schéma, on a juste fait figurer les 4 connecteurs de 4 contacts chacun qui sont présents sur le shield.

Fichier hébergé par Archive-Host.com

Voici un programme de démo qui fait tourner, successivement, chaque moteur en avant puis en arrière. Pas d’interactivité dans ce petit programme, on déroule juste une séquence.


// shield relais V4

// commande de 4 moteurs
// vitesse et sens variables
// un seul moteur commandé à la fois

// correspondances pin - relais
// ok pour DFR0144 V2.1

byte Pin_relais[4] = {2,7,8,10};

// On utilise la sortie moteur M1 du DFRduino
// comme source d'alim pour les 4 moteurs à commander
 
int Pin_M1_sens = 4 ; // le sens M1 est commandé par la Pin 4

int Pin_M1_pwm = 5 ; //  la vitesse M1 est commandée par la Pin 5
 
 
void setup(){
  
  for(int i = 0; i < 4; i++)  pinMode(Pin_relais[i],OUTPUT);
 
  pinMode(Pin_M1_sens,OUTPUT);
 
  pinMode(Pin_M1_pwm,OUTPUT);
 
 
}
 
void loop(){  
  
  
    ////////////////////premier moteur ///////////////////////////

  /// mettre en marche 5 secondes le premier moteur en marche avant
  
  // en faisant coller le relais 1 : COM1 et NO1 en contact
  
  // l'alimentation est prise de la sortie M1 du DFRduino
  
  // pour tous les moteurs
  
  ///////////////////moteur 1 /////////////////////////////////
  
  controle(1,1,10);// moteur 1, sens avant, vitesse 10
  
  delay(5000);
  
  controle(0,0,0) ; // arret tous moteurs
  
  delay(1000);
  
  //////////////////////////////////////////////////////
  
  controle(1,0,10);// moteur 1, sens arriere, vitesse 10
  
  delay(5000);
  
  controle(0,0,0) ; // arret tous moteurs
  
  delay(1000);
  
  
  //////////////////// moteur 2 ////////////////////////////////
  
  controle(2,1,10);// moteur 2, sens avant, vitesse 10
  
  delay(5000);
  
  controle(0,0,0) ; // arret tous moteurs
  
  delay(1000);
  
  //////////////////////////////////////////////////////
  
  controle(2,0,10);// moteur 2, sens arriere, vitesse 10
  
  delay(5000);
  
  controle(0,0,0) ; // arret tous moteurs
  
  delay(1000);
  
  
  /////////////////////moteur 3 ///////////////////////////////
  
  controle(3,1,5);// moteur 3, sens avant, vitesse 10
  
  delay(5000);
  
  controle(0,0,0) ; // arret tous moteurs
  
  delay(1000);
  
  //////////////////////////////////////////////////////
  
  controle(3,0,5);// moteur 3, sens arriere, vitesse 10
  
  delay(5000);
  
  controle(0,0,0) ; // arret tous moteurs
  
  delay(1000);
  
  
   
  /////////////////////moteur 4 ///////////////////////////////
  
  controle(4,1,5);// moteur 4, sens avant, vitesse 5
  
  delay(5000);
  
  controle(0,0,0) ; // arret tous moteurs
  
  delay(1000);
  
  //////////////////////////////////////////////////////
  
  controle(4,0,5);// moteur 4, sens arriere, vitesse 5
  
  delay(5000);
  
  controle(0,0,0) ; // arret tous moteurs
  
  delay(1000);       
 
}


// la procedure de controle des moteurs

void controle (int m, int sens, int v)         
 
 // m : 1, 2, 3, 4  choix moteur
 // si m = 0 arret tous moteurs

 // sens : 1 ou 0 (avant ou arrière)
 // v : vitesse de 0 à 10, 

{       
        int pwm, i;
        
        // couper l'alim des relais : les contacts NC et COM ne se touchent plus 
        for(i = 0; i < 4; i++)  digitalWrite(Pin_relais[i],LOW);
        
        delay(100);
        
        if (m >0) {
        
        // alimenter le relais correspondant au moteur désiré
        digitalWrite(Pin_relais[m-1],HIGH);
        
        // paramétrer la sortie moteur M1 du DFRduino
        // qui va alimenter le moteur choisi
        
        pwm = map(v, 0,10, 0,255); // ramener vitesse à l'intervalle 0 255
        digitalWrite(Pin_M1_sens,sens);  // fixer sens
        analogWrite (Pin_M1_pwm,pwm);    // fixer vitesse
        delay(100);
        
        }                            
}

Est-ce la solution miracle pour transformer un DFRduino à deux sorties moteur en un DFRduino à 4 sorties ? Eh non ! En effet les 4 moteurs s’alimentent sur la même sortie M1 de la carte donc ne peuvent pas être utilisés simultanément avec des vitesses ou des sens différents ce que l’on ferait si on avait 4 sorties indépendantes.