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.

Shield relais (partie 1)

Voici un shield qui permet de commander par programme un ensemble d’interrupteurs.

Fichier hébergé par Archive-Host.com

Pour ce premier exemple, on a choisi un montage limpide (on utilise les contacts COM et NO du relais 1) et un programme très rustique.


// shield relais V0

//Pin2 commande le relais 1
 
void setup(){

  pinMode(2,OUTPUT);

}
 
void loop(){  

  // mettre en marche 5 secondes en faisant coller le relais 1 
  // COM1 et NO1 en contact
  // la lampe s'allume

  digitalWrite(2,HIGH);

  delay(5000);

  // stopper une seconde l'alim du relais 1 
  // COM1 et NO1 ne sont plus en contact
  // la lampe s'éteint

  digitalWrite(2,LOW);

  delay(1000);
 
}

En portant la pin 2 à l’état haut, les contacts COM1 et NO1 se touchent ce qui ferme le circuit et permet à la lampe de s’allumer.

COM désigne le contact commum
NO veut dire Normally Open
NC veut dire Normally Closed

Quand la bobine du relais n’est pas alimentée, COM et NO ne sont pas en contact mais COM et NC le sont.

Quand la bobine du relais est alimentée, COM et NO sont en contact mais COM et NC ne le sont pas.

Remarquer qu’il faut alimenter la carte DFRduino par sa prise d’alim (au moins 7,5v) ; l’alimentation USB ne délivre pas assez de tension pour faire coller le relais.

Le modèle est un DFRobot DFR0144 Version 2.1.

Ruse : les programmes présents aujourd’hui (16/06/2013) sur le site de DFRobot sont écrits pour une version antérieure du shield… et ne fonctionnent pas avec le shield V 2.1 à cause d’une correspondance pin/ relais qui a changé.

Pour cette version 2.1 la correspondance pin / relais est la suivante :

PIN 2 -> relais 1
PIN 7 -> relais 2
PIN 8 -> relais 3
PIN 10 -> relais 4

Capteurs magnétiques et Arduino : un V2 en meccano-elec

Fichier hébergé par Archive-Host.com

Dans ce bi-cylindre en V, façon moteur de moto Harley Davidson, on utilise de très petits aimants, petits mais costauds ! Le programme est le même que le précédent, les branchements sont les mêmes, seuls les réglages des capteurs et aimants différent. Le volant comporte un contrepoids important pour équilibrer l’ensemble mobile.

On peut aussi utiliser le code suivant où l’on autorise les deux bobines à travailler en même temps si les deux détecteurs le commandent. Une alimentation de 12 V suffit pour entraîner l’ensemble avec allégresse quand les réglages des aimants sont effectués avec soin.


// bicylindre meccano-elec
// controle de l'alimentation de bobine
// grace à 2 mini-aimants et
// 2 capteurs magnetiques DFR0033
// special moteur "Harley"
// on autorise que les deux bobines soient actives en meme temps
 
int E1 = 5;     //M1 vitesse
 
int M1 = 4;     //M1 sens

int E2 = 6;     //M2 vitesse
 
int M2 = 7;     //M2 sens

// Quand l'aimant est détecté le signal est à l'état bas
 
int detection = 0; 
 
// signal du detecteur magnetique 1 sur Pin 8
int sensor1Pin = 8 ;
// signal du detecteur magnetique 2 sur Pin 9
int sensor2Pin = 9 ;
 
// Led qui s'allume quand la bobine1 est alimentée
int led1Pin = 11; 

// Led qui s'allume quand la bobine2 est alimentée
int led2Pin = 12; 

 
void setup(void)
{
    // controle sortie moteur M1
    // utilisée pour la bobine
    pinMode(E1, OUTPUT); 
    pinMode(M1, OUTPUT); 
    
    // controle sortie moteur M2
    // utilisée pour la bobine
    pinMode(E2, OUTPUT); 
    pinMode(M2, OUTPUT); 
    
    
    // capteurs magnetique
    pinMode(sensor1Pin,INPUT);    
    pinMode(sensor2Pin,INPUT);
    
    // led de controle
    pinMode(led1Pin,OUTPUT);
    pinMode(led2Pin,OUTPUT);
  
    digitalWrite(M1,HIGH);   // fixer sens en avant
    digitalWrite(M2,HIGH);   // fixer sens en avant    
   
}
 
void loop(void)
{  
   
  if (digitalRead(sensor1Pin) == detection )  
      { 
        // allumer Led pour controle
        digitalWrite   (led1Pin, HIGH); 
        digitalWrite   (led2Pin, LOW); 
       // alimenter bobine plein pot  
        analogWrite(E1,255);       
       }
  
    if (digitalRead(sensor2Pin) == detection )  
      { 
        // allumer Led pour controle
        digitalWrite   (led2Pin, HIGH);
        digitalWrite   (led1Pin, LOW); 
        
       // alimenter bobine 2 plein pot  
        analogWrite(E2,255);
       }
      
      if ((digitalRead(sensor1Pin) != detection ) && (digitalRead(sensor2Pin) != detection ) )
      
          {  analogWrite(E1,0);      
             analogWrite(E2,0);
             digitalWrite(led1Pin, LOW);
             digitalWrite(led2Pin, LOW); 
           }
      
}