Les actionneurs physiques : Différence entre versions

int solenoide = 11;

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

/*
  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);          
}

/*
  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); 
}

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
}

/*
  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);
}

/* 
 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); 
}