4- Annexes

Voici les annexes et plus particulièrement les programmes que nous avons conçus.

PROGRAMME BALAYAGE SERVO-MOTEUR :

#include <Servo.h>

 

Servo monServo;

int angle = 0;

 

void setup()

{

monServo.attach(2,650,2340);

}

 

void loop()

{

for (angle = 0; angle < 180 ; angle++)

{

monServo.write(angle);

delay(5);

}

 

for (angle ; angle > 0 ; angle–)

{

monServo.write(angle);

delay(5);

}

}

 

PROGRAMME DE MESURE (AVEC MOYENNE) DE DISTANCE ENVOYE A L’ORDINATEUR :

 

int capteur;

float lecture;

int cumul = 0;

int mesure_brute;

float cm;

 

 

 

 

void setup()

{

Serial.begin(9600);

 

}

 

void loop()

{

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

Serial.println(cm);

delay(1000);

 

 

 

}

 

PROGRAMME SI L’UN DES CEUX CAPTEUR DETECTE UN OBSTACLE TOURNER A GAUCHE OU A DROITE SUIVANT CM1 > CM2 ou CM2> CM1 :

 

#include <Servo.h>

int capteur1=0;

int capteur2=1;

 

float lecture;

int cumul = 0;

int mesure_brute;

float cm1;

float cm2;

Servo monServo;

 

 

const int sensMoteur1=4; // Constante pour la broche 2

const int vitesseMoteur1=5;// Constante pour la broche 3

 

const int sensMoteur2=7; // Constante pour la broche 2

const int vitesseMoteur2=6;// Constante pour la broche 3

 

const int AVANT=0; // constante sens moteur

const int ARRIERE=1; // constante sens moteur

int vitesse1=150;

int vitesse2 =140;

int angle = 0;

 

 

void setup()

{

Serial.begin(9600);

monServo.attach(2,650,2340);

monServo.write(90);

delay(2000);

}

 

void loop()

{

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if (cm1 > cm2)

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

 

}

 

 

 

 

 

LE MEME MAIS AVEC BALAYAGE :

 

#include <Servo.h>

int capteur1=0;

int capteur2=1;

 

float lecture;

int cumul = 0;

int mesure_brute;

float cm1;

float cm2;

Servo monServo;

 

 

const int sensMoteur1=4; // Constante pour la broche 2

const int vitesseMoteur1=5;// Constante pour la broche 3

 

const int sensMoteur2=7; // Constante pour la broche 2

const int vitesseMoteur2=6;// Constante pour la broche 3

 

const int AVANT=0; // constante sens moteur

const int ARRIERE=1; // constante sens moteur

int vitesse1=150;

int vitesse2 =140;

int angle = 0;

 

 

void setup()

{

Serial.begin(9600);

monServo.attach(2,650,2340);

monServo.write(90);

delay(2000);

}

 

void loop()

{

 

for (angle =65 ;angle < 150 ; angle++)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if (cm1 > cm2)

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

}

 

 

 

 

 

for (angle ; angle > 65 ;angle–)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if (cm1 > cm2)

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

 

}

 

}

 

 

LE MEME AVEC DETECTION DE CM1= CM2 ET DONC ARRET DU ROBOT :

 

#include <Servo.h>

int capteur1=0;

int capteur2=1;

 

float lecture;

int cumul = 0;

int mesure_brute;

float cm1;

float cm2;

Servo monServo;

 

 

const int sensMoteur1=4; // Constante pour la broche 2

const int vitesseMoteur1=5;// Constante pour la broche 3

 

const int sensMoteur2=7; // Constante pour la broche 2

const int vitesseMoteur2=6;// Constante pour la broche 3

 

const int AVANT=0; // constante sens moteur

const int ARRIERE=1; // constante sens moteur

int vitesse1=150;

int vitesse2 =140;

int angle = 0;

 

 

void setup()

{

Serial.begin(9600);

monServo.attach(2,650,2340);

monServo.write(90);

delay(2000);

}

 

void loop()

{

 

for (angle =65 ;angle < 150 ; angle++)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if ( (cm1 > cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

if ( (cm1 < cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

}

else

{

analogWrite(vitesseMoteur1, 0); // génère une impulsion PWM sur la broche de vitesse du moteur

 

analogWrite(vitesseMoteur2, 0); // génère une impulsion PWM sur la broche de vitesse du moteur

delay(1000);

}

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

}

 

 

 

 

 

for (angle ; angle > 65 ;angle–)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if ( (cm1 > cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

if ( (cm1 < cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

}

else

{

analogWrite(vitesseMoteur1, 0); // génère une impulsion PWM sur la broche de vitesse du moteur

 

analogWrite(vitesseMoteur2,0); // génère une impulsion PWM sur la broche de vitesse du moteur

delay(1000);

}

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

 

}

 

}

 

 

AJOUT D’UNE ROTATION A DROITE LORSQUE CM1 = CM2 :

 

#include <Servo.h>

int capteur1=0;

int capteur2=1;

 

float lecture;

int cumul = 0;

int mesure_brute;

float cm1;

float cm2;

Servo monServo;

 

 

const int sensMoteur1=4; // Constante pour la broche 2

const int vitesseMoteur1=5;// Constante pour la broche 3

 

const int sensMoteur2=7; // Constante pour la broche 2

const int vitesseMoteur2=6;// Constante pour la broche 3

 

const int AVANT=0; // constante sens moteur

const int ARRIERE=1; // constante sens moteur

int vitesse1=150;

int vitesse2 =140;

int angle = 0;

 

 

void setup()

{

Serial.begin(9600);

monServo.attach(2,650,2340);

monServo.write(90);

delay(2000);

}

 

void loop()

{

 

for (angle =65 ;angle < 150 ; angle++)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if ( (cm1 > cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

if ( (cm1 < cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

}

else

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

delay(460);

}

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

}

 

 

 

 

 

for (angle ; angle > 65 ;angle–)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if ( (cm1 > cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

if ( (cm1 < cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

}

else

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

delay(460);

}

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

 

}

 

}

 

 

 

AJOUT D’UN SENS DE ROTATION EN FONCTION DE LA POSITION DU SERVOMOTEUR :

#include <Servo.h>

int capteur1=0;

int capteur2=1;

 

float lecture;

int cumul = 0;

int mesure_brute;

float cm1;

float cm2;

Servo monServo;

 

 

const int sensMoteur1=4; // Constante pour la broche 2

const int vitesseMoteur1=5;// Constante pour la broche 3

 

const int sensMoteur2=7; // Constante pour la broche 2

const int vitesseMoteur2=6;// Constante pour la broche 3

 

const int AVANT=0; // constante sens moteur

const int ARRIERE=1; // constante sens moteur

int vitesse1=150;

int vitesse2 =140;

int angle = 0;

 

 

void setup()

{

Serial.begin(9600);

monServo.attach(2,650,2340);

monServo.write(90);

delay(2000);

}

 

void loop()

{

 

for (angle =65 ;angle < 150 ; angle++)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if ( (cm1 > cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

if ( (cm1 < cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

}

 

 

else

{

 

if (65 <= angle <= 108)

{ analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

delay(460);

}

else

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

delay(460);

 

}

 

}

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

}

 

 

 

 

 

for (angle ; angle > 65 ;angle–)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if ( (cm1 > cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

if ( (cm1 < cm2) & (((cm1 – cm2) > 2) || ( (cm1 – cm2) < -2 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

}

 

 

else

{

 

if (65 <= angle <= 108)

{ analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

delay(460);

}

else

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

delay(460);

 

}

 

}

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

 

}

 

}

 

 

 

 

 

AJOUT DE LA PROPROTIONALITE DE LA ROTATION :

 

#include <Servo.h>

int capteur1=0;

int capteur2=1;

 

float lecture;

int cumul = 0;

int mesure_brute;

float cm1;

float cm2;

Servo monServo;

 

 

const int sensMoteur1=4; // Constante pour la broche 2

const int vitesseMoteur1=5;// Constante pour la broche 3

 

const int sensMoteur2=7; // Constante pour la broche 2

const int vitesseMoteur2=6;// Constante pour la broche 3

 

const int AVANT=0; // constante sens moteur

const int ARRIERE=1; // constante sens moteur

int vitesse1=150;

int vitesse2 =140;

int angle = 0;

int tdt = 0;//tdt ou Temps de tournant est la variable qui stock le temps qu’il faut pour tourner en fonction de la position du servo

 

 

void setup()

{

Serial.begin(9600);

monServo.attach(2,650,2340);

monServo.write(90);

delay(2000);

}

 

void loop()

{

 

for (angle =65 ;angle < 150 ; angle++)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if ( (cm1 > cm2) & (((cm1 – cm2) > 5) || ( (cm1 – cm2) < -5 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

if ( (cm1 < cm2) & (((cm1 – cm2) > 5) || ( (cm1 – cm2) < -5 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

}

 

 

else

{

 

if (65 <= angle <= 108) //si le servo et du coté gauche

{ analogWrite(vitesseMoteur1, vitesse1); //tourne à droite

digitalWrite(sensMoteur1,AVANT);

analogWrite(vitesseMoteur2, vitesse1);

digitalWrite(sensMoteur2,ARRIERE); //mainteant on choisit une durré de tournant proportionnel à la position du servo

tdt = map (angle,65,108,0,460);

delay(tdt);

}

else

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

tdt = map (angle,108,150,0,460);

delay(tdt);

 

}

 

}

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

}

 

 

 

 

 

for (angle ; angle > 65 ;angle–)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if ( (cm1 > cm2) & (((cm1 – cm2) > 5) || ( (cm1 – cm2) < -5 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

if ( (cm1 < cm2) & (((cm1 – cm2) > 5) || ( (cm1 – cm2) < -5 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

}

 

 

else

{

 

if (65 <= angle <= 108) //si le servo et du coté gauche

{ analogWrite(vitesseMoteur1, vitesse1); //tourne à droite

digitalWrite(sensMoteur1,AVANT);

analogWrite(vitesseMoteur2, vitesse1);

digitalWrite(sensMoteur2,ARRIERE); //mainteant on choisit une durré de tournant proportionnel à la position du servo

tdt = map (angle,65,108,0,460);

delay(tdt);

}

else

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

tdt = map (angle,108,150,0,460);

delay(tdt);

 

}

 

}

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

 

}

 

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

AJOUT DU RECULE AVANT ROTATION PROPORTIONNEL(à pofinner)

 

 

 

#include <Servo.h>

int capteur1=0;

int capteur2=1;

 

float lecture;

int cumul = 0;

int mesure_brute;

float cm1;

float cm2;

Servo monServo;

 

 

const int sensMoteur1=4; // Constante pour la broche 2

const int vitesseMoteur1=5;// Constante pour la broche 3

 

const int sensMoteur2=7; // Constante pour la broche 2

const int vitesseMoteur2=6;// Constante pour la broche 3

 

const int AVANT=0; // constante sens moteur

const int ARRIERE=1; // constante sens moteur

int vitesse1=150;

int vitesse2 =140;

int angle = 0;

int tdt = 0;//tdt ou Temps de tournant est la variable qui stock le temps qu’il faut pour tourner en fonction de la position du servo

 

 

void setup()

{

Serial.begin(9600);

monServo.attach(2,650,2340);

monServo.write(90);

delay(2000);

}

 

void loop()

{

 

for (angle =65 ;angle < 150 ; angle++)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if ( (cm1 > cm2) & (((cm1 – cm2) > 5) || ( (cm1 – cm2) < -5 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

if ( (cm1 < cm2) & (((cm1 – cm2) > 5) || ( (cm1 – cm2) < -5 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

}

 

 

else

{

 

if (65 <= angle <= 108) //si le servo et du coté gauche

{ //tourne à droite

digitalWrite(sensMoteur1,ARRIERE);

 

digitalWrite(sensMoteur2,ARRIERE);

delay(500);

 

analogWrite(vitesseMoteur1, vitesse1); //tourne à droite

digitalWrite(sensMoteur1,AVANT);

analogWrite(vitesseMoteur2, vitesse1);

digitalWrite(sensMoteur2,ARRIERE); //mainteant on choisit une durré de tournant proportionnel à la position du servo

tdt = map (angle,65,108,0,460);

delay(tdt);

}

else

{

digitalWrite(sensMoteur1,ARRIERE);

 

digitalWrite(sensMoteur2,ARRIERE);

delay(500);

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

tdt = map (angle,108,150,0,460);

delay(tdt);

 

}

 

}

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

}

 

 

 

 

 

for (angle ; angle > 65 ;angle–)

{

monServo.write(angle);

delay(3);

/*****************************************************/

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

 

while(cm1 < 25 || cm2 < 25 )

{

if ( (cm1 > cm2) & (((cm1 – cm2) > 5) || ( (cm1 – cm2) < -5 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,ARRIERE); // Marche avant

}

 

else

{

if ( (cm1 < cm2) & (((cm1 – cm2) > 5) || ( (cm1 – cm2) < -5 )) )

{

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

}

 

 

else

{

 

if (65 <= angle <= 108) //si le servo et du coté gauche

{digitalWrite(sensMoteur1,ARRIERE);

 

digitalWrite(sensMoteur2,ARRIERE);

delay(500);

analogWrite(vitesseMoteur1, vitesse1); //tourne à droite

digitalWrite(sensMoteur1,AVANT);

analogWrite(vitesseMoteur2, vitesse1);

digitalWrite(sensMoteur2,ARRIERE); //mainteant on choisit une durré de tournant proportionnel à la position du servo

tdt = map (angle,65,108,0,460);

delay(tdt);

}

else

{

digitalWrite(sensMoteur1,ARRIERE);

 

digitalWrite(sensMoteur2,ARRIERE);

delay(500);

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,ARRIERE); // Marche avant

analogWrite(vitesseMoteur2, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

tdt = map (angle,108,150,0,460);

delay(tdt);

 

}

 

}

}

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur1);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm1 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

for (int i=0; i<50; i++) // répète la mesure

{

mesure_brute = analogRead(capteur2);

cumul= cumul+mesure_brute;

 

}

lecture = cumul/50;

cumul = 0;

cm2 = ( (87.3)* pow(lecture,-1.09) )* pow(10,2) ;

 

 

}

 

analogWrite(vitesseMoteur1, vitesse1); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur1,AVANT); // Marche avant

analogWrite(vitesseMoteur2, vitesse2); // génère une impulsion PWM sur la broche de vitesse du moteur

digitalWrite(sensMoteur2,AVANT); // Marche avant

 

/*****************************************************/

 

}

 

}

 

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s