Les actionneurs physiques

De Wiki L.A.B
Aller à : navigation, rechercher

Les solénoïdes

Matériel
  • Arduino Uno
  • Plaque d'essai (breadboard)
  • Straps ou fils de liaison
  • 1 Solénoïde 5v (https://www.sparkfun.com/products/11015)
  • 1 Résistance 2,2 kΩ
  • 1 Diode de roue libre 1N4007
  • 1 Transistor 2N2222A (ou BC547)
Principe

Un solénoïde est un actionneur linéaire simple particulièrement adapté pour pousser ou tirer. Le solénoïde que nous utiliserons est de petite dimension et peut être commandé avec une tension de 5V (celle fournie par le port USB du PC par exemple).

D'un point de vue physique, un solénoïde est un electro-aimant qui pousse (ou tire) une tige lorsqu'il est activé. Pour l'activer, il faut alimenter la bobine avec une source de tension. L'intensité nécessaire (<=500mA) étant relativement importante, on ne peut pas brancher directement le solénoïde sur une sortie de l'Arduino (qui peut délivrer maximum 40mA).

Solenoide.jpg

Pour le piloter, il faut donc utiliser un transistor. Des transistors, il en existe de différents types et pour différentes applications : amplification de courant/tension, commutation, etc. répartis dans plusieurs familles. L'objectif n'est pas de faire exhaustif sur toutes les possibilités de ces composants mais uniquement de les utiliser pour commander une charge. Dans ce mode de fonctionnement, on peut voir le transistor comme un interrupteur que l'on commande électroniquement.

Le transistor que nous allons utiliser est dit bipolaire. Il a trois broches, chacune ayant une fonction propre :

  • une broche d’entrée (Collecteur),
  • une broche de sortie (Émetteur)
  • une broche de commande (Base).

Son symbole est le suivant :

Transitor.png

Celui que nous allons utiliser est un 2N2222A. Les données constructeurs sont synthètisées dans le tableau ci-dessous :

Fabricant Vce Ic PD fT
ST Microelectronics 2N2222A 40 V 800 mA 500 mW/1.8 W 300 MHz

La mise en boitier est la suivante :

2N2222A and schema.jpg

Montage

Le montage est le suivant : Solenoide bb.png

Solenoide schema.png

Programme

Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino. Ce programme active le solénoïde toute les secondes et le relâche 

int solenoide = 11;

void setup() {                
  pinMode(solenoide, OUTPUT);     
}
void loop() {
  digitalWrite(solenoide, HIGH);   // Active le solenoide
  delay(50);               
  digitalWrite(solenoide, LOW);    // Relache
  delay(1000);
}

Se faire tourner la tête en continu : Pilotage simple d'un moteurs à courant continu

Matériel
  • Arduino Uno
  • Plaque d'essai (breadboard)
  • Straps ou fils de liaison
  • 1 moteur à courant continu 5v
  • 1 Résistance 2,2 kΩ
  • 1 Diode de roue libre 1N4007
  • 1 Transistor 2N2222A (ou BC547)
Principe

Le moteur à courant continu est l'actionneur rotatif le plus simple qui existe. Pour mettre le moteur en mouvement, il suffit d'appliquer une tension à ses bornes. La vitesse de rotation d'un moteur à courant continu est proportionnelle à la valeur de la tension.

Le pilotage simple d'un moteur se fait de manière identique au pilotage d'un solénoïde. Le montage fait dans cette réalisation sera exactement le même que le précédent, le solénoïde sera juste remplacé par un moteur à courant continu.

Montage

MoteurCC bb.png

MoteurCC schéma.png

Programme

Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino. 

/*
  Ce programme active le moteur toute les secondes pendant une seconde.
*/

int moteur = 6;

void setup() {                
  pinMode(moteur, OUTPUT);     
}
void loop() {
  digitalWrite(moteur, HIGH);  
  delay(1000);              
  digitalWrite(moteur, LOW);   
  delay(1000);          
}

/*
  Ce programme démarre progressivement le moteur et le ralentit tout aussi progressivement.
*/

int moteur = 6;

void setup() {                
  pinMode(moteur, OUTPUT);     
}
void loop() {
    analogWrite(moteur, 255);
    delay(100);  
    for(int i=100; i <= 255; ++i){
        analogWrite(moteur, i);  
        delay(100);         
    }

    for(int i=255; i > 100; --i){
        analogWrite(moteur, i);  
        delay(100);         
    }             
    digitalWrite(moteur, LOW);   
    delay(1000);          
}

Tourner sur soi-même sans se perdre : Pilotage simple d'un moteurs à courant continu avec un capteur infrarouge

Matériel
  • Arduino Uno
  • Plaque d'essai (breadboard)
  • Straps ou fils de liaison
  • 1 moteur à courant continu 5v
  • 1 Résistance 2,2 kΩ
  • 1 Diode de roue libre 1N4007
  • 1 Transistor 2N2222A (ou BC547)
  • 1 optocoupleur en fourche type Liton LTH 307-01
Principe

Comme on l'a vu précédemment, le moteur à courant continu fonctionne sans donner aucune information sur sa position ou sur le nombre de tours qu'il a effectués. Pour contourner ce problème, il faut lui adjoindre un capteur supplémentaire permettant de connaitre le nombre de tours faits. La solution classique est d'utiliser une fourche optique et une roue à fente.

Arduino opto fourche ledx1.png

La fourche optique est une sorte de capteur de passage qui retourne 0V quand il y a un obstacle entre la fourche et +5V quand il n'y a pas d'obstacle. Quand on met la roue à fente entre les dents de la fourche optique, le capteur passera de 0 à 1 puis de 1 à 0 à chaque passage de fente. Pour connaitre le nombre de tours faits au total, il suffit de compter le nombre de fronts montants.

Montage

Le montage est le même que précédemment auquel on rajoute la fourche optique sur la broche 2 de l'Arduino.

MoteurCC bb.png

MoteurCC schéma.png

Programme

Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino. 

/*
  Ce programme permet de vérifier qu'un objet est présent au milieu d'une fourche optique
*/


// Pins utilisées
const int fourchePin = 2;     //Sortie de la fourche
const int ledPin =  13;        // LED témoin sur pin

int EtatFourche = 0;

void setup() {
  Serial.begin(9600);   //connection au port série 
  pinMode(ledPin, OUTPUT);     //LED en sortie
  pinMode(fourchePin, INPUT);  //en entrée
  Serial.println("Fourche optique - detection de presence");
}

void loop() {  
    //Vérifie si un objet obture la fourche optique
  EtatFourche = digitalRead(fourchePin);
  
  Serial.print("Etat ");
  if (EtatFourche == HIGH) {     
    // Allumer la LED témoin
    digitalWrite(ledPin, HIGH); 
     Serial.println("Presence"); 
  } 
  else {
    // Eteindre la LED
    digitalWrite(ledPin, LOW); 
    Serial.println("Vide"); 
  }
  delay(200);
}

/*
  Ce programme permet de compter les impulsions en provenance d'une roue codeuse
*/

// Pins utilisées
const int fourchePin = 2;     //Sortie de la fourche
const int ledPin =  13;        // LED témoin sur pin

int EtatFourche = 0;
int nbImpulsion = 0;

void comptageDUneImpulsion(){
    nbImpulsion++;
}

void setup() {
  Serial.begin(9600);   //connection au port série 
  pinMode(ledPin, OUTPUT);     //LED en sortie
  pinMode(fourchePin, INPUT);  //en entrée
  Serial.println("Fourche optique - compteur d'impulsions");
  attachInterrupt(0, comptageDUneImpulsion, CHANGE);
}

void loop() {
   delay(500);
   Serial.print("Nombre d'impulsion :");
   Serial.println(nbImpulsion); 
}

/*
  Ce programme permet de compter les impulsions en provenance d'une roue codeuse
*/

// Pins utilisées
const int fourchePin = 2;     //Sortie de la fourche
const int ledPin =  13;        // LED témoin sur pin
const int moteur = 6;


int nbImpulsion = 0;
int nbImpulsionDemande = 0;

void comptageDUneImpulsion(){
    if(nbImpulsion >= nbImpulsionDemande){
        digitalWrite(moteur, LOW);
    }
    else{
        nbImpulsion++;
    }
}

void avancer(int _nbImpulsion){
    detachInterrupt(0);
    nbImpulsion = 0;
    nbImpulsionDemande = _nbImpulsion;
    digitalWrite(moteur, HIGH); 
    attachInterrupt(0, comptageDUneImpulsion, CHANGE);
}

void setup() {
  Serial.begin(9600);   //connection au port série 
  pinMode(ledPin, OUTPUT);     //LED en sortie
  pinMode(fourchePin, INPUT);  //en entrée
  Serial.println("Fourche optique - compteur d'impulsions"); 
}

void loop() {
   delay(500);
   Serial.print("Nombre d'impulsion :");
   Serial.println(nbImpulsion); 
}

Aller dans tous les sens : Pilotage avancé d'un moteurs à courant continu avec un pont en H

Matériel
Principe

Jusqu'à présent nous avons commandé des moteurs à courant continu avec uniquement un seul transistor. Cette solution est suffisante tant que l'on n'a pas besoin de changer de sens de rotation. Pour changer de sens de rotation, il faut changer la polarité du courant.

Pour réaliser cette tache, il faut utiliser un montage spécial appelé pont en H :

Pont H.png

Le pont en H permet de choisir le sens du courant en fonction de l'état des 4 interrupteurs (ils peuvent être remplacés par des transistors) qui le composent. Pour comprendre le fonctionnement de ce pont en H (appelé ainsi à cause de sa forme), imaginons que l'on ferme les transistors 1 et 4 en laissant ouverts le 2 et le 3. Le courant passe de la gauche vers la droite.

Pont H sens 1.png

Si en revanche on fait le contraire (2 et 3 fermés et 1 et 4 ouverts), le courant ira dans l’autre sens.

Pont H sens 2.png

Le pont en H a d'autres configurations valides permettant de gérer le freinage du moteur.

Dans notre cas, nous n'allons pas câbler le pont en H mais nous allons directement utiliser le shield moteur. Ce shield est basé sur un L298 qui contient 2 ponts en H permettant de piloter des moteurs demandant une intensité maximale inférieure à 2A.

MotorShield R3 Front 450px.jpg

Le câblage du shield est le suivant :

Fonction Canal A Canal B
Direction Digital 12 Digital 13
Vitesse (PWM) Digital 3 Digital 11
Frein Digital 9 Digital 8
Intensité Analog 0 Analog 1
Montage

Le montage du shield revient juste à emboîter le shield dans l'arduino et à câbler les deux moteurs dans les borniers à vis étiquetés A et B.

MotorShield R3 Montage.jpg

Shield moteur bb.png

Programme

Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino. 

const int vitesseMotA=3; // Constante pour la broche 3
const int sensMotA=12; // Constante pour la broche 12
const int freinMotA=9; // Constante pour la broche 9
const int intensiteMotA=A0; // intensité du moteur 0

const int vitesseMotB=11; // Constante pour la broche 11
const int sensMotB=13; // Constante pour la broche 13
const int freinMotB=8; // Constante pour la broche 8
const int intensiteMotB=A1; // intensité du moteur 1

void setup()   {
    
    Serial.begin(115200); 

    pinMode (vitesseMotA,OUTPUT); // Broche vitesseMotA configurée en sortie
    pinMode (freinMotA,OUTPUT); // Broche freinMotA configurée en sortie
    pinMode (vitesseMotB,OUTPUT); // Broche vitesseMotB configurée en sortie
    pinMode (sensMotA,OUTPUT); // Broche sensMotA configurée en sortie
    pinMode (sensMotB,OUTPUT); // Broche senMotB configurée en sortie
    digitalWrite(vitesseMotA,LOW); // a l'arret
    digitalWrite(sensMotA,LOW); 
    digitalWrite(freinMotA,LOW); // frein off 

    digitalWrite(vitesseMotB,LOW); // à l'arret 
    digitalWrite(sensMotB,LOW);  
    digitalWrite(freinMotB,LOW); // frein off

} 


void loop(){
    //------ test initial du moteur A ---- 
    //- sens 1
    digitalWrite(sensMotA,LOW); // sens 1
    digitalWrite(vitesseMotA, HIGH); // vitesse maximale
    delay(2000); // 2 secondes
    digitalWrite(vitesseMotA, LOW); // vitesse maximale
    
    //- sens 2
    digitalWrite(sensMotA,HIGH); // sens 2
    digitalWrite(vitesseMotA, HIGH); // vitesse maximale
    delay(1000); // 2 secondes
    Serial.println(analogRead(intensiteMotA)); 
    delay(1000); // 2 secondes
    digitalWrite(vitesseMotA, LOW); // vitesse maximale
    
    
    //------ test initial du moteur B ---- 
    //- sens 1
    digitalWrite(sensMotB,LOW); // sens 1
    digitalWrite(vitesseMotB, HIGH); // vitesse maximale
    delay(2000); // 2 secondes
    digitalWrite(vitesseMotB, LOW); // vitesse maximale
    
    //- sens 2
    digitalWrite(sensMotB,HIGH); // sens 2
    digitalWrite(vitesseMotB, HIGH); // vitesse maximale
    delay(1000); // 2 secondes
    Serial.println(analogRead(intensiteMotB)); 
    delay(1000); // 2 secondes
    digitalWrite(vitesseMotB, LOW); // vitesse maximale
    
    //---- test vitesse variable moteur A --- 
    
    for (int i=0; i<=255; i++) {
      analogWrite(vitesseMotA,i); // PWM croissant
      delay(50); // pause
      Serial.println(analogRead(intensiteMotA)); 
    
    }
    
    for (int i=0; i<=255; i++) {
      analogWrite(vitesseMotA,255-i); // PWM décroissant
      delay(50); // pause
      Serial.println(analogRead(intensiteMotA)); 
    }
    
    //---- test vitesse variable moteur B --- 
    
    for (int i=0; i<=255; i++) {
      analogWrite(vitesseMotB,i); // PWM croissant
      delay(50); // pause
      Serial.println(analogRead(intensiteMotB)); 
    
    }
    
    for (int i=0; i<=255; i++) {
      analogWrite(vitesseMotB,255-i); // PWM décroissant
      delay(50); // pause
      Serial.println(analogRead(intensiteMotB)); 
    
    }
     
    while(1); // stop loop
}

Un moteur qui sait ou il va : le servomoteur

Matériel
  • Arduino Uno
  • Plaque d'essai (breadboard)
  • Straps ou fils de liaison
  • Un servomoteur
  • Un potentiomètre
Principe

Les servomoteurs sont des actionneurs rotatifs asservis en position. Cela veut simplement dire que pour commander un servo, il suffit de lui donner l'angle qu'il doit atteindre et qu'il se débrouille pour se mettre en position et y rester. Contrairement au moteur à courant continu, on sait donc toujours où est notre moteur sans avoir à ajouter de l’électronique.

Ils sont très utilisés en modélisme et on en trouve vraiment à tous les prix. Généralement en plus de l'asservissement en position, les servos ont un fort couple. Si on regarde à l'intérieur, le couple est apporté par un moto-réducteur au dessus d'un simple moteur à courant continu. L'asservissement en position, est géré grâce à un potentiomètre sur l'axe moteur.

Montage

Le montage d'un servo est très simple, il y a 3 fils. Le rouge va au 5V, le noir à la masse(GND) et le jaune sur un broche digitale.

Servo.png

Programme

Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino. 

/*
  Ce programme fait faire un balayage à un servomoteur  
*/

#include <Servo.h> 
 
Servo myservo;
 
int pos = 0;
 
void setup() 
{ 
  myservo.attach(2);
} 
 
 
void loop() 
{ 
  for(pos = 0; pos < 180; pos += 1)  
  {                                  
    myservo.write(pos);              
    delay(15);                       
  } 
  for(pos = 180; pos>=1; pos-=1)     
  {                                
    myservo.write(pos);             
    delay(15); 
  } 
}

/*
  Ce programme permet de contrôler un servo grâce à un potentiometre 
*/
#include <Servo.h> 
 
Servo myservo;  
 
const int potpin = 0;  
int val;     
 
void setup() 
{ 
  myservo.attach(2); 
} 
 
void loop() 
{ 
  val = analogRead(potpin);            
  val = map(val, 0, 1023, 0, 179);      
  myservo.write(val);                  
  delay(150);
}

Avancer un pas après l'autre : le moteur pas à pas

Matériel
Principe

Ce moteur possède quatre fils d’alimentation pour piloter des bobines par paire. Etant donné un schéma vaut mieux qu’un long discours, voici comment il est constitué :

Pap principe.png

Vous l’aurez compris, les bobines sont reliées deux à deux en série et sont donc pilotées ensemble. Il n’y a donc finalement que deux enroulements à commander puisque deux bobines montées en série n’en font plus qu’une. Leur placement de part et d’autre de l’aimant permanent du rotor permet de piloter ce dernier.

Lorsqu’il n’y a aucun courant traversant les bobines, le rotor (où l’axe de sortie est lié) est libre de tourner, rien ne cherche à le retenir dans sa course. Maintenant, si nous décidons de faire passer du courant entre les points C et D pour alimenter la bobine de gauche et celle de droite, un courant va s’établir et deux champs électromagnétiques vont apparaître de part et d’autres du rotor. Que va-t-il alors se passer ? L’aimant du rotor va tourner sur lui même pour se placer de façon à ce que son pôle Nord soit en face du pôle Sud du champ magnétique créé dans la première bobine et que son pôle Sud soit en face du pôle Nord créé dans la deuxième bobine. Si on alimente non plus les bobines entre C et D mais plutôt entre A et B, le rotor va alors tourner pour s’aligner à nouveau vers les pôles qui l’intéressent (Nord/Sud, Sud/Nord). Ensuite on recommence, on va alors alimenter de nouveau les bobines entre D et C, donc avec un courant de signe opposé à la fois où elles ont été alimentées entre C et D (par exemple C était relié au “+” de l’alimentation tout à l’heure et là on le fait passer au “-”, idem pour D que l’on fait passer du “-” au “+”) et le moteur va encore faire un quart de tour. On peut continuer ainsi de suite pour faire tourner le moteur en faisant attention de ne pas se tromper dans les phases d’alimentation. A chaque phase, on va donc faire tourner le moteur d’un quart de tour :

Pap phase.png

Ce quart de rotation s’appelle un pas. Et comme il faut plusieurs pas pour faire tourner le moteur sur 360°, on l’a donc appelé ainsi, le moteur pas-à-pas.

Dans le cas illustré ci-dessus, on dit que le moteur fait 4 pas par tour. Il existe bien des moteurs qui font ce nombre de pas mais ce ne sont pas les plus fréquents. Généralement le nombre de pas par tour est bien plus conséquent (24, 48, 180,...). La constitution mécanique de leur rotor est plus complexe (le rotor comporte autant d'aimants que de pas par tour), mais le principe de fonctionnement reste identique. On cherche toujours à attirer un aimant grâce à des champs magnétiques crées par des bobines parcourues par un courant.

Montage

Le montage consiste simplement à emboîter le shield dans l'arduino et à câbler les deux moteurs dans les borniers à vis étiquetés A et B.

MotorShield R3 Montage.jpg

PaP.jpg

Programme

Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino. 

/* 
 Stepper Motor Control with Arduino Motor Control Shield V3.0.
 */
const int dirA = 12;
const int dirB = 13;

const int motA = 3;
const int motB = 11;

const int brakeA = 9;
const int brakeB = 8;

const int delayLength = 30;

void setup() {
  pinMode(dirA, OUTPUT);
  pinMode(dirB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);
  pinMode(motA, OUTPUT);
  pinMode(motB, OUTPUT);
}

void loop() {
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, HIGH);
  
  digitalWrite(dirA, HIGH);
  digitalWrite(motA, HIGH);
  
  delay(delayLength);
  
  digitalWrite(brakeA, HIGH);
  digitalWrite(brakeB, LOW);
  
  digitalWrite(dirB, HIGH);
  digitalWrite(motB, HIGH);

  delay(delayLength);
  
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, HIGH);
  
  digitalWrite(dirA, LOW);
  digitalWrite(motA, HIGH);
  
  delay(delayLength);
  
  digitalWrite(brakeA, HIGH);
  digitalWrite(brakeB, LOW);
  
  digitalWrite(dirB, LOW);
  digitalWrite(motB, HIGH);
  
  delay(delayLength); 
}



/* 
 Stepper Motor Control with Arduino Motor Control Shield V3.0.

 This program drives a bipolar stepper motor. The motor is controlled
 by Arduino pins 10, 11, 12, 13.

 The motor should do five revolutions into one and five into another direction.

 Using this sketch for longer is not recommended because it will keep the motor under current
 and can cause it to become quite hot.

 */

#include <Stepper.h>

int enA  = 3;  // Enable pin 1 on Motor Control Shield   
int enB  = 11;  // Enable pin 2 on Motor Control Shield   
int dirA = 12;  // Direction pin dirA on Motor Control Shield
int dirB = 13;  // Direction pin dirB on Motor Control Shield


const int stepsPerRevolution = 180;  // Change this to fit the number of steps per revolution
                                     // for your motor

// Initialize the stepper library on pins 12 and 13:
Stepper myStepper(stepsPerRevolution, dirA, dirB);            


void setup() {
  // set the speed at 60 rpm:
  myStepper.setSpeed(60);

  // Enable power to the motor
  pinMode(enA, OUTPUT);
  digitalWrite (enA, HIGH);

  pinMode(enB, OUTPUT);
  digitalWrite (enB, HIGH);  
}

void loop() {
  // Step five revolutions into one direction:
  myStepper.step(stepsPerRevolution*5);
  delay(2000);

  // Step five revolutions in the other direction:
  myStepper.step(-stepsPerRevolution*5);
  delay(2000); 
}
Récupérée de « http://wiki.labaixbidouille.com/index.php?title=Les_actionneurs_physiques&oldid=377 »