RobotTondeuse : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
(→‎{{Bleu|Objectif}})
(→‎{{Bleu|Code des différents composants}})
 
(134 révisions intermédiaires par le même utilisateur non affichées)
Ligne 5 : Ligne 5 :
 
=Présentation du projet=
 
=Présentation du projet=
  
−
[[Fichier:tondeuse.jpg|500px||turbo tondeuse]]
+
[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] <br />
  
−
Le but de ce projet est de concevoir un robot tondeuse autonome. <br />
 
  
  
 +
[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]
  
−
 
−
 
 
  
  
Ligne 19 : Ligne 17 :
 
Le projet consiste à fabriquer un robot tondeuse autonome capable d'éviter les obstacles grâce à des capteurs de distance et faire tourner un moteur brushless désignant la lame de la tondeuse. <br />
 
Le projet consiste à fabriquer un robot tondeuse autonome capable d'éviter les obstacles grâce à des capteurs de distance et faire tourner un moteur brushless désignant la lame de la tondeuse. <br />
  
−
=={{Bleu|Découpage fonctionnel}}==
+
=={{Bleu|Tâches individuelles}}==
 +
 
 +
* Arel RAKO :
  
−
[[Fichier:Decodeur fil pilote fonctions.jpg|800px||découpage fonctionnel]]
+
    * capteur VL53L1X
 +
      - programmé et connecté le capteur
  
−
=={{Bleu|Contraintes de fabrication}}==
+
    * moteur brushless
 +
      - programmé, connecté, fait les soudures nécessaires pour le connecteur de la batterie
  
 +
    * interrupteur
 +
      - programmé en PULL UP pour faire tourner le moteur à l'état haut et l'arrêter à l'état bas
  
 +
    * plaque pastillée
 +
      - toutes les soudures de la plaque, qui seront détaillés un peu plus tard
 +
* Anthony JEAN-BAPTISTE-ADOLPHE :
  
 +
    * gyroscope MPU9250
 +
    - programmé et connecté le gyroscope
  
 +
    * capteur VL53L1X
 +
    - programmation pour faire fonctionner 3 capteurs en même temps avec le gyroscope aussi
  
 +
    * code général
 +
    - programmation
  
 +
    * différentes soudures
  
 +
=={{Bleu|Découpage fonctionnel}}==
  
 +
[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]
  
 +
= Travail à réaliser =
  
 
=={{Bleu|Objectif}}==
 
=={{Bleu|Objectif}}==
Ligne 45 : Ligne 62 :
 
- '''programmer''' les composants <br />
 
- '''programmer''' les composants <br />
 
- '''valider''' le fonctionnement <br />
 
- '''valider''' le fonctionnement <br />
 +
 +
=={{Bleu|Choix des composants}}==
 +
 +
- 3 capteurs de distance VL53L1X <br />
 +
- 1 arduino uno <br />
 +
- 1 shield avec drivers <br />
 +
- 1 gyroscope MPU9250 <br />
 +
- 1 batterie EMMERICH 12.8V <br />
 +
- 1 abaisseur de tension LM2596 <br />
 +
- 1 moteur brushless <br />
 +
- 1 interrupteur <br />
 +
- 2 moteurs MDP (moteurs des roues) <br />
 +
 +
[[Fichier:Photo VL53L1X.jpg|300px||VL53L1x]]  [[Fichier:Photo arduino uno.png|300px||Arduino Uno]]
 +
[[Fichier:Photo MPU9250.jpg|300px||MPU9250]]  [[Fichier:Photo LM2596.jpg|300px||LM2596]]
 +
[[Fichier:Photo moteur brushless.jpg|300px||Moteur Brushless]]
 +
[[Fichier:Driver.png|200px||Driver]]
 +
[[Fichier:MoteurMDP.jpg|200px|Moteur MDP]]
 +
[[Fichier:Interrupteur.jpg|200px|Interrupteur]]
 +
[[Fichier:Batterie 12.8V.jpg|200px|Batterie]]
 +
 +
[[Fichier:Tondeuse composants.jpg|600px]]
 +
 +
=={{Bleu|Explications}}==
 +
 +
=== Les capteurs de distance ===
 +
 +
    * connectés en I2C via les ports SCL et SDA de l'arduino
 +
    * alimentés en 5V via le pin VIN, ils possèdent un régulateur qui transforme le 5V en 2.8V (sortie VDD)
 +
    * placés au côté gauche, droit et au milieu du robot pour avoir un plus grand champ de vision
 +
    * détails de fonctionnement: <br />
 +
      - si le capteur à gauche détecte un obstacle à moins de 20cm, le robot tourne à droite
 +
      - si le capteur à droite détecte un obstacle à moins de 20cm, le robot tourne à gauche
 +
      - si le capteur du milieu détecte un obstacle à moins de 20cm, le robot s'arrête et fait demi-tour vers la droite
 +
 +
=== Le gyroscope ===
 +
 +
    * Connecté en I2C comme les capteurs de distance
 +
    * Alimenté en 5V comme les capteurs de distance
 +
    * Fait la somme de 100 angles et fait leur moyenne pour plus de précision
 +
 +
=== Moteur Brushless ===
 +
 +
    * Connecté à un pin PWM de l'Arduino pour pouvoir le piloter
 +
    * Alimenté directement via la batterie car nécessite 12V
 +
    * Sur le rotor on a mis du scotch pour modéliser la lame
 +
 +
=== Interrupteur ===
 +
 +
    * connecté en PULL-UP à un pin quelconque de l'arduino
 +
    * alimenté en 5V
 +
    * s'il envoie 1, le moteur brushless commence à tourner, s'il envoie 0, le moteur s'arrête '''Attention! Prévoir 5 secondes pour l'arrêt du moteur'''
 +
 +
=== Abaisseur de tension ===
 +
 +
    * transforme le 12V de la batterie en 5V pour alimenter les capteurs
 +
 +
=== Plaque pastillée ===
 +
 +
    * constituée de 6 parties:
 +
      - le 12V pour alimenter l'arduino, on y branche aussi le connecteur AMASS du moteur brushless et l'abaisseur de tension
 +
      - le 5V où sont connectés tous les capteurs, le gyroscope et l'interrupteur
 +
      - SCL où est connecté le pin SCL des capteurs et du gyroscope au pin SCL de l'arduino
 +
      - SDA où est connecté le pin SDA des capteurs et du gyroscope au pin SDA de l'arduino
 +
      - masse du 12V
 +
      - masse du 5V
 +
 +
=== Moteurs MDP ===
 +
 +
    * Ces moteurs sont pilotés par deux pins, le pin Mx qui permet de définir le sens de rotation du rotor en le mettant à l'état haut ou à l'état bas, puis il y a le pin Ex qui permet de définir la vitesse de rotation du rotor, c'est un pin analogique. On met le pin à 255 pour avoir la vitesse maximale.
 +
 +
=={{Bleu|Programmation}}==
 +
 +
 +
==={{Bleu|Code des différents composants}}===
 +
 +
* programmation des capteurs de distance
 +
  Bibliothèque  pour le capteur de distance : [https://github.com/pololu/vl53l1x-arduino Bibliothèque]
 +
 +
{{boîte déroulante/début|titre=Code distance}}
 +
<source lang=c>
 +
#include <Wire.h>
 +
#include <VL53L1X.h>
 +
 +
VL53L1X sensor;  // Déclaration des sensors
 +
VL53L1X sensor2;
 +
VL53L1X sensor3;
 +
 +
//USE_I2C_2V8K;
 +
void setup()
 +
{
 +
  pinMode(2, OUTPUT);  // On déclare les pins en sortie
 +
  pinMode(3, OUTPUT);
 +
  pinMode(4, OUTPUT);
 +
 
 +
  digitalWrite(2, LOW);  // On met les sorties à l'état bas pour définir leurs adresses
 +
  digitalWrite(3, LOW);
 +
  digitalWrite(4, LOW);
 +
 
 +
// Initialisation I2C
 +
  delay(500);
 +
  Wire.begin();
 +
  Wire.beginTransmission(0x29);
 +
  Serial.begin (9600);
 +
 +
  digitalWrite(3,HIGH);  // On met la sortie à l'état haut pour définir l'adresse de la sortie
 +
  delay(150);
 +
  sensor2.init();  // On initialise le capteur
 +
  Serial.println("01");
 +
  delay(100);
 +
  sensor2.setAddress(0x33); // On définit l'adresse du capteur
 +
  Serial.println("02");
 +
 +
  digitalWrite(4,HIGH); // On met la sortie à l'état haut pour définir l'adresse de la sortie
 +
  delay(150);
 +
  sensor3.init();  // On initialise le capteur
 +
  Serial.println("03");
 +
  delay(100);
 +
  sensor3.setAddress(0x35);  // On définit l'adresse du capteur
 +
  Serial.println("04");
 +
 +
  digitalWrite(2, HIGH);  // On n'a pas besoin de définir l'adresse du premier capteur, il garde son adresse de base
 +
  delay(150);
 +
  Serial.println("09");
 +
  sensor.init();
 +
  Serial.println("10");
 +
  delay(100);
 +
 +
  sensor.setDistanceMode(VL53L1X::Long);  // On définit le mode du capteur
 +
  sensor.setMeasurementTimingBudget(50000);
 +
  sensor.startContinuous(50);
 +
  sensor.setTimeout(100);
 +
 +
  sensor2.setDistanceMode(VL53L1X::Long);  // On définit le mode du capteur
 +
  sensor2.setMeasurementTimingBudget(50000);
 +
  sensor2.startContinuous(50);
 +
  sensor2.setTimeout(100);
 +
 
 +
  sensor3.setDistanceMode(VL53L1X::Long);  // On définit le mode du capteur
 +
  sensor3.setMeasurementTimingBudget(50000);
 +
  sensor3.startContinuous(50);
 +
  sensor3.setTimeout(100);
 +
 
 +
  delay(150);
 +
  Serial.println("addresses set");
 +
 +
  Serial.println ("I2C scanner. Scanning ..."); // C'est un programme pour voir combien et quelles sont adresses des différents composants utilisant l'I2C
 +
  byte count = 0;
 +
 +
  for (byte i = 1; i < 120; i++)
 +
  {
 +
 +
    Wire.beginTransmission (i);
 +
    if (Wire.endTransmission () == 0)
 +
    {
 +
      Serial.print ("Found address: ");
 +
      Serial.print (i, DEC);
 +
      Serial.print (" (0x");
 +
      Serial.print (i, HEX);
 +
      Serial.println (")");
 +
      count++;
 +
      delay (1);
 +
    } // end of good response
 +
  } // end of for loop
 +
  Serial.println ("Done.");
 +
  Serial.print ("Found ");
 +
  Serial.print (count, DEC);
 +
  Serial.println (" device(s).");
 +
 +
 +
}
 +
 +
void loop()
 +
{
 +
  Serial.print("Sensor1: "); 
 +
  Serial.print(sensor.read());  // écrit la distance du capteur 1
 +
  if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
 +
  Serial.println();
 +
  delay(500);
 +
  Serial.print("Sensor2: ");  // écrit la distance du capteur 2
 +
  Serial.print(sensor2.read());
 +
  if (sensor2.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
 +
  Serial.println();
 +
  delay(500);
 +
  Serial.print("Sensor3: ");  // écrit la distance du capteur 3
 +
  Serial.print(sensor3.read());
 +
  if (sensor3.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
 +
  Serial.println();
 +
  delay(500);
 +
}
 +
</source>
 +
{{boîte déroulante/fin}}
 +
 +
* programmation moteur brushless avec l'interrupteur
 +
 +
{{boîte déroulante/début|titre=Code brushless}}
 +
<source lang=c>
 +
const int escPin = 5;  // pin de commande
 +
int a= digitalRead(13); // pin interrupteur
 +
 +
 +
void setup() {
 +
  //Init Serial
 +
  Serial.begin(9600);
 +
  Serial.println(F("Initialize System"));
 +
  //Init ESC
 +
  pinMode(escPin, OUTPUT); // on met le pin en sortie pour pouvoir le piloter
 +
 +
}
 +
void loop() {
 +
   
 +
 +
a= digitalRead(13);
 +
Serial.println(a);
 +
 +
if(a<1)
 +
{
 +
 +
Serial.println(a);
 +
 +
}else {
 +
  Serial.println(a);
 +
 +
  digitalWrite(escPin, HIGH); // fait un signal carré qui permet la commutation rapide entre état haut et bas,  ce qui permet de faire tourner le moteur
 +
  delayMicroseconds(1350);
 +
  digitalWrite(escPin, LOW);
 +
  delay(20);
 +
}
 +
 +
}
 +
</source>
 +
{{boîte déroulante/fin}}
 +
 +
* programmation gyroscope
 +
  Bibliothèque du MPU9250 : [https://github.com/bolderflight/MPU9250#mpu9250/lien Bibliothèque]
 +
 +
{{boîte déroulante/début|titre=Code gyro}}
 +
<source lang=c>
 +
 +
#include "MPU9250.h"
 +
 +
MPU9250 IMU(Wire,0x68);
 +
int status;
 +
 +
 +
 +
double moyenne;
 +
double moyenneFinal;
 +
int i;
 +
 +
 +
double angle(){
 +
  double Module_magnetic;
 +
  double angle;
 +
  double Xmagnetic;
 +
  double Ymagnetic;
 +
  double Zmagnetic;
 +
 +
  IMU.readSensor();
 +
 +
  Xmagnetic = IMU.getMagX_uT();
 +
  Ymagnetic = IMU.getMagY_uT();
 +
  Zmagnetic = IMU.getMagZ_uT();
 +
 
 +
 +
   
 +
  Module_magnetic = Xmagnetic * Xmagnetic + Ymagnetic * Ymagnetic + Zmagnetic * Zmagnetic; // formule pour définir l'angle en degré
 +
  Module_magnetic = sqrt(Module_magnetic);
 +
 
 +
  angle= atan2(Ymagnetic,Xmagnetic) * (180 / 3.14159265); // angle en degré
 +
  if (angle<0) {angle=angle+360;}
 +
 
 +
  return angle;
 +
}
 +
 +
void setup() {
 +
 +
  Serial.begin(115200);
 +
  while(!Serial) {}
 +
 +
  // début de la communication IMU
 +
  status = IMU.begin();
 +
  if (status < 0) {
 +
    Serial.println("IMU initialization unsuccessful");
 +
    Serial.println("Check IMU wiring or try cycling power");
 +
    Serial.print("Status: ");
 +
    Serial.println(status);
 +
    while(1) {}
 +
  }
 +
  // setting the accelerometer full scale range to +/-8G
 +
  IMU.setAccelRange(MPU9250::ACCEL_RANGE_8G);
 +
  // setting the gyroscope full scale range to +/-500 deg/s
 +
  IMU.setGyroRange(MPU9250::GYRO_RANGE_500DPS);
 +
  // setting DLPF bandwidth to 20 Hz
 +
  IMU.setDlpfBandwidth(MPU9250::DLPF_BANDWIDTH_20HZ);
 +
  // setting SRD to 19 for a 50 Hz update rate
 +
  IMU.setSrd(19);
 +
}
 +
 +
void loop() {
 +
 +
 +
  //Module du champ
 +
 +
  Serial.print("  ");
 +
  Serial.print("Angle  ");  //en degré
 +
  Serial.println(angle());
 +
 +
 +
  moyenne = 0;
 +
  for (i=0; i<100; i++)
 +
  {
 +
    moyenne = moyenne + angle();
 +
    delay(10);
 +
 +
  }
 +
 
 +
  moyenneFinal = moyenne/100;
 +
  Serial.print("Moyenne : ");
 +
  Serial.println(moyenneFinal);
 +
 
 +
 
 +
  // Affiche les différentes valeurs du capteur
 +
  Serial.print("AccelX : ");
 +
  Serial.print(IMU.getAccelX_mss(),6);
 +
  Serial.print("\t");
 +
  Serial.print("AccelY : ");
 +
  Serial.print(IMU.getAccelY_mss(),6);
 +
  Serial.print("\t");
 +
  Serial.print("AccelZ : ");
 +
  Serial.print(IMU.getAccelZ_mss(),6);
 +
  Serial.print("\t");
 +
  Serial.print("GyroX : ");
 +
  Serial.print(IMU.getGyroX_rads(),6);
 +
  Serial.print("\t");
 +
  Serial.print("GyroY : ");
 +
  Serial.print(IMU.getGyroY_rads(),6);
 +
  Serial.print("\t");
 +
  Serial.print("GyroZ : ");
 +
  Serial.print(IMU.getGyroZ_rads(),6);
 +
  Serial.print("\t");
 +
  Serial.print("MagX : ");
 +
  Serial.print(IMU.getMagX_uT(),6);
 +
  Serial.print("\t");
 +
  Serial.print("MagY: ");
 +
  Serial.print(IMU.getMagY_uT(),6);
 +
  Serial.print("\t");
 +
  Serial.print("MagZ : ");
 +
  Serial.print(IMU.getMagZ_uT(),6);
 +
  Serial.print("\n");
 +
  Serial.print("Temp : ");
 +
  Serial.println(IMU.getTemperature_C(),6);
 +
  delay(1000);
 +
 
 +
}
 +
 +
</source>
 +
{{boîte déroulante/fin}}
 +
 +
* programmation moteurs MDP
 +
 +
{{boîte déroulante/début|titre=Code moteurs MDP}}
 +
<source lang=c>
 +
int E1 = 5;    // Moteur droite
 +
int M1 = 4;   
 +
int E2 = 6;    // Moteur gauche
 +
int M2 = 7;
 +
 +
 +
void setup() {
 +
 +
  Serial.println("Initialisation des moteurs...");
 +
  pinMode(M1, OUTPUT);
 +
  pinMode(M2, OUTPUT);
 +
  pinMode(E1, OUTPUT);
 +
  pinMode(E2, OUTPUT);
 +
  Serial.println("Moteurs opérationnels");
 +
}
 +
 +
void loop {
 +
 +
  //mode marche avant (m1 high m2 low)
 +
  //mode marche arrière (m1 low m2 high)
 +
  //tourner à gauche (m1 high m2 high)
 +
  //tourner à droite (m1 low m2 low)
 +
 
 +
 +
    digitalWrite(M1,LOW);
 +
    digitalWrite(M2,HIGH);
 +
    analogWrite(E1, 255);
 +
    analogWrite(E2, 255);
 +
    delay(30);
 +
 +
}
 +
</source>
 +
{{boîte déroulante/fin}}
 +
 +
==={{Bleu|Code général}}===
 +
 +
{{boîte déroulante/début|titre=Code tondeuse}}
 +
<source lang=cpp>
 +
 +
#include <Arduino.h>
 +
#include <Moteurs.h>
 +
#include <Wire.h>
 +
#include <VL53L1X.h>
 +
#include "MPU9250.h"
 +
 +
int E1 = 5;    // Moteur droite
 +
int M1 = 4;   
 +
int E2 = 6;    // Moteur gauche
 +
int M2 = 7;
 +
 +
int escPin = 5; // Pin de contrôle moteur simulation lame
 +
int a = digitalRead(12);
 +
 +
 +
VL53L1X sensor;  // Déclaration des sensors
 +
VL53L1X sensor2;
 +
VL53L1X sensor3;
 +
MPU9250 IMU(Wire,0x68);
 +
 +
int status;
 +
 +
void setupLaser();  // Déclaration des variable et des fonctions
 +
void setupLame();
 +
void runLame();
 +
void setupMoteurs();
 +
double readGyro();
 +
void setupGyro();
 +
double angle();
 +
void Moteurs();
 +
 +
 +
void setup() {
 +
  Serial.begin(115200);
 +
  Wire.begin();
 +
  Wire.setClock(400000);
 +
  setupGyro();
 +
  setupLaser();
 +
  setupMoteurs();
 +
 
 +
   
 +
}
 +
 +
void loop(){ 
 +
             
 +
  runLame(); // fonction qui fait tourner le moteur de coupe
 +
 +
  // Affiche les différentes valeurs des capteurs
 +
  Serial.print(" Distance 1 : ");
 +
  Serial.print(sensor.read());
 +
  Serial.print(" - Distance 2 : ");
 +
  Serial.print(sensor2.read());
 +
  Serial.print(" - Distance 3 : ");
 +
  Serial.print(sensor3.read());
 +
  Serial.print("\tEtat: ");
 +
  Serial.print(VL53L1X::rangeStatusToString(sensor.ranging_data.range_status));
 +
  Serial.print(" Angle : ");
 +
  Serial.println(angle());
 +
 +
  runLame();
 +
 +
  if((sensor3.read())<=150) //capteur 3 est à droite
 +
  {
 +
    digitalWrite(M1,HIGH); //tourner à gauche
 +
    digitalWrite(M2,HIGH);
 +
    analogWrite(E1, 180);
 +
    analogWrite(E2, 150);
 +
    delay(300);
 +
  }else
 +
  {
 +
    digitalWrite(M1,HIGH); // marche avant
 +
    digitalWrite(M2,LOW);
 +
    analogWrite(E1, 150);
 +
    analogWrite(E2, 170);
 +
    delay(30);
 +
  }
 +
  runLame();
 +
  if((sensor2.read())<=200) //capteur 2 est devant milieu
 +
  {
 +
    digitalWrite(M1,LOW); // reculer à gauche
 +
    digitalWrite(M2,HIGH);
 +
    analogWrite(E1, 100);
 +
    analogWrite(E2, 200);
 +
    delay(1000);
 +
    digitalWrite(M1,LOW); // arrêt
 +
    digitalWrite(M2,HIGH);
 +
    analogWrite(E1, 0);
 +
    analogWrite(E2, 0);
 +
    delay(1000);
 +
    digitalWrite(M1,HIGH); //marche avant
 +
    digitalWrite(M2,LOW);
 +
    analogWrite(E1, 150);
 +
    analogWrite(E2, 170);
 +
    delay(30);
 +
  }else
 +
  {
 +
    digitalWrite(M1,HIGH); //marche avant
 +
    digitalWrite(M2,LOW);
 +
    analogWrite(E1, 150);
 +
    analogWrite(E2, 170);
 +
    delay(30);
 +
  }
 +
  runLame();
 +
  if((sensor.read())<=150) //capteur 1 est à gauche
 +
  {
 +
    digitalWrite(M1,LOW); // tourner à droite
 +
    digitalWrite(M2,LOW);
 +
    analogWrite(E1, 150);
 +
    analogWrite(E2, 150);
 +
    delay(300);
 +
  }else
 +
  {
 +
    digitalWrite(M1,HIGH); // marche avant
 +
    digitalWrite(M2,LOW);
 +
    analogWrite(E1, 150);
 +
    analogWrite(E2, 170);
 +
    delay(30);
 +
  }
 +
 
 +
  runLame();
 +
 
 +
  }
 +
 +
double angle(){
 +
  double angle;
 +
  double Xmagnetic;
 +
  double Ymagnetic;
 +
 +
  IMU.readSensor();
 +
 +
  Xmagnetic = IMU.getMagX_uT();
 +
  Ymagnetic = IMU.getMagY_uT();
 +
 
 +
  angle= atan2(Ymagnetic,Xmagnetic) * (180 / 3.14159265); // angle en degres
 +
  if (angle<0) {angle=angle+360;}
 +
 
 +
  return angle;
 +
}
 +
 +
void setupGyro(){
 +
  Serial.println("Initialisation du Gyroscop...");
 +
    status = IMU.begin();
 +
  if (status < 0) {
 +
    Serial.println("IMU initialization unsuccessful");
 +
    Serial.println("Check IMU wiring or try cycling power");
 +
    Serial.print("Etat: ");
 +
    Serial.println(status);
 +
    Serial.println("Problème avec le Gyroscop");
 +
  }
 +
  // setting the accelerometer full scale range to +/-8G
 +
  IMU.setAccelRange(MPU9250::ACCEL_RANGE_8G);
 +
  // setting the gyroscope full scale range to +/-500 deg/s
 +
  IMU.setGyroRange(MPU9250::GYRO_RANGE_500DPS);
 +
  // setting DLPF bandwidth to 20 Hz
 +
  IMU.setDlpfBandwidth(MPU9250::DLPF_BANDWIDTH_20HZ);
 +
  // setting SRD to 19 for a 50 Hz update rate
 +
  IMU.setSrd(19);
 +
  Serial.println("Gyroscope opérationnel");
 +
}
 +
 +
double readGyro(){
 +
  double moyenne;
 +
  double moyenneFinal;
 +
  moyenne = 0;
 +
  for (int j =0; j<100; j++)
 +
  {
 +
    moyenne = moyenne + angle();
 +
    delay(10);
 +
 +
  }
 +
 
 +
  moyenneFinal = moyenne/100;
 +
  return moyenneFinal;
 +
}
 +
 +
void setupLaser(){
 +
  pinMode(2, OUTPUT);  // On déclare les pins en sortie
 +
  pinMode(3, OUTPUT);
 +
  pinMode(4, OUTPUT);
 +
 
 +
  digitalWrite(2, LOW);  // On met les sorties à l'état bas pour définir leurs adresses
 +
  digitalWrite(3, LOW);
 +
  digitalWrite(4, LOW);
 +
 +
// initialise I2C
 +
  delay(500);
 +
  Wire.begin();
 +
  Wire.beginTransmission(0x29);
 +
 +
  digitalWrite(3,HIGH); // On met la sortie à l'état haut pour définir l'adresse de la sortie
 +
  delay(150);
 +
  sensor2.init(); // On initialise le capteur
 +
  Serial.println("01");
 +
  delay(100);
 +
  sensor2.setAddress(0x33); // On définit l'adresse du capteur
 +
  Serial.println("02");
 +
 +
  digitalWrite(4,HIGH); // On met la sortie à l'état haut pour définir l'adresse de la sortie
 +
  delay(150);
 +
  sensor3.init();  // On initialise le capteur
 +
  Serial.println("03");
 +
  delay(100);
 +
  sensor3.setAddress(0x35); // On définit l'adresse du capteur
 +
  Serial.println("04");
 +
 +
  digitalWrite(2, HIGH); // On n'a pas besoin de définir l'adresse du premier capteur, il garde son adresse de base
 +
  delay(150);
 +
  Serial.println("09");
 +
  sensor.init();
 +
  Serial.println("10");
 +
  delay(100);
 +
 +
  sensor.setDistanceMode(VL53L1X::Long);  // On définit le mode du capteur
 +
  sensor.setMeasurementTimingBudget(50000);
 +
  sensor.startContinuous(50);
 +
  sensor.setTimeout(100);
 +
 +
  sensor2.setDistanceMode(VL53L1X::Long);  // On définit le mode du capteur
 +
  sensor2.setMeasurementTimingBudget(50000);
 +
  sensor2.startContinuous(50);
 +
  sensor2.setTimeout(100);
 +
 
 +
  sensor3.setDistanceMode(VL53L1X::Long);  // On définit le mode du capteur
 +
  sensor3.setMeasurementTimingBudget(50000);
 +
  sensor3.startContinuous(50);
 +
  sensor3.setTimeout(100);
 +
 
 +
  delay(150);
 +
  Serial.println("addresses set");
 +
 +
  Serial.println ("I2C scanner. Scanning ...");  // C'est un programme pour voir combien et quelles sont adresses des différents composants utilisant l'I2C
 +
  byte count = 0;
 +
 +
 +
  for (byte i = 1; i < 120; i++)
 +
  {
 +
 +
    Wire.beginTransmission (i);
 +
    if (Wire.endTransmission () == 0)
 +
    {
 +
      Serial.print ("Found address: ");
 +
      Serial.print (i, DEC);
 +
      Serial.print (" (0x");
 +
      Serial.print (i, HEX);
 +
      Serial.println (")");
 +
      count++;
 +
      delay (1);
 +
    }
 +
  }
 +
  Serial.println ("Done.");
 +
  Serial.print ("Found ");
 +
  Serial.print (count, DEC);
 +
  Serial.println (" device(s).");
 +
}
 +
 +
void setupMoteurs(){
 +
  Serial.println("Initialisation des moteurs...");
 +
  pinMode(M1, OUTPUT);
 +
  pinMode(M2, OUTPUT);
 +
  pinMode(E1, OUTPUT);
 +
  pinMode(E2, OUTPUT);
 +
  Serial.println("Moteurs opérationnels");
 +
}
 +
 +
void runLame(){
 +
  pinMode (5, OUTPUT);
 +
  pinMode (12, INPUT);
 +
 +
  a= digitalRead(12);
 +
  if(a<1){
 +
      Serial.println(a);
 +
 +
  }
 +
  else {
 +
   
 +
      Serial.println(a);
 +
 +
  digitalWrite(escPin, HIGH);  // fait un signal carré qui permet la commutation rapide entre état haut et bas,  ce qui permet de faire tourner le moteur
 +
  delayMicroseconds(1350);
 +
  digitalWrite(escPin, LOW);
 +
  delay(20);
 +
      } 
 +
}
 +
 +
 +
void Moteurs()
 +
{
 +
 
 +
  //mode marche avant (m1 high m2 low)
 +
  //mode marche arrière (m1 low m2 high)
 +
  //tourner à gauche (m1 high m2 high)
 +
  //tourner à droite (m1 low m2 low)
 +
 
 +
 +
    digitalWrite(M1,LOW);
 +
    digitalWrite(M2,HIGH);
 +
    analogWrite(E1, 255);
 +
    analogWrite(E2, 255);
 +
    delay(30);
 +
 +
}
 +
 +
// End of file
 +
  </source>
 +
{{boîte déroulante/fin}}
 +
 +
= Tests réalisés =
 +
 +
=={{Bleu|Capteurs de distance}}==
 +
 +
* Nous avons connecté un seul capteur pour commencer sur une platine à essai avec un arduino uno avec le programme fourni par le constructeur, et avons vérifié que le capteur
 +
nous donne une valeur correcte. Nous avons ensuite connecté les 3 capteurs en série sur la platine d'essai toujours, et avons vérifié qu'ils affichaient une valeur différente
 +
grâce à leur différente adresse.
 +
 +
=={{Bleu|Gyroscope}}==
 +
 +
* On a testé le code du gyroscope avec le capteur seul sur une platine d'essai, le code a été trouvé sur internet. Le code fonctionnait bien, on avait les valeurs de la magnitude en X, Y et Z. Pareil pour l'accélération et on avait aussi la température. Puis on a programmé un code permettant de faire une boussole pour avoir l'angle par rapport au nord magnétique. Ensuite on a mis en commun avec les capteurs de distance, il n'y a pas besoin de redéfinir son adresse vu qu'elle est déjà différente des capteurs de distance.
 +
 +
=={{Bleu|Moteur brushless}}==
 +
 +
* Nous avons testé plusieurs codes qui permettaient de faire tourner le moteur mais aucun ne le faisait tourner en continu. Pour ce faire, nous avons modifié un code qui permettait de faire du RUN / STOP pendant un certain temps fixé. (voir ci-contre)
 +
 +
{{boîte déroulante/début|titre=Code pour RUN / STOP}}
 +
<source lang=cpp>
 +
 +
//Parameters
 +
const int escPin = 3;
 +
int min_throttle = 1000;
 +
int max_throttle = 2000;
 +
unsigned long currentMillis, previousMillis;
 +
 +
void setup() {
 +
//Init Serial USB
 +
Serial.begin(9600);
 +
Serial.println(F("Initialize System"));
 +
//Init ESC
 +
pinMode(escPin, OUTPUT);
 +
initProcedure();
 +
}
 +
void loop() {
 +
  runBrushless();
 +
 +
}
 +
void runBrushless() {
 +
Serial.println("running");
 +
currentMillis = 0;
 +
previousMillis = millis();
 +
while (currentMillis < 2000) {
 +
currentMillis = millis() - previousMillis;
 +
digitalWrite(escPin, HIGH);
 +
delayMicroseconds(1350);
 +
digitalWrite(escPin, LOW);
 +
delay(20);
 +
}
 +
Serial.println("stop");
 +
currentMillis = 0;
 +
previousMillis = millis();
 +
while (currentMillis < 2000) {
 +
currentMillis = millis() - previousMillis;
 +
digitalWrite(escPin, HIGH);
 +
delayMicroseconds(min_throttle);
 +
digitalWrite(escPin, LOW);
 +
delay(20);
 +
}
 +
}
 +
void initProcedure() {
 +
previousMillis = millis();
 +
Serial.println("throttle up");
 +
while (currentMillis < 3000) {
 +
currentMillis = millis() - previousMillis;
 +
Serial.println(currentMillis);
 +
digitalWrite(escPin, HIGH);
 +
delayMicroseconds(max_throttle);
 +
digitalWrite(escPin, LOW);
 +
delay(20);
 +
}
 +
currentMillis = 0;
 +
previousMillis = millis();
 +
Serial.println("throttle down");
 +
while (currentMillis < 4500) {
 +
currentMillis = millis() - previousMillis;
 +
Serial.println(currentMillis);
 +
digitalWrite(escPin, HIGH);
 +
delayMicroseconds(min_throttle);
 +
digitalWrite(escPin, LOW);
 +
delay(20);
 +
}
 +
}
 +
  </source>
 +
{{boîte déroulante/fin}}
 +
 +
=={{Bleu|Moteurs MDP}}==
 +
 +
On a testé les moteurs en mettant le pin M1 du moteur de droite à l'état haut et le pin M2 à l'état haut et les pins E1 et E2 à 255, on a vu que le robot tournait à gauche. Ainsi on a testé toutes les possibilités, cela nous a permis de définir la marche avant, la marche arrière, tourner à gauche et à droite. Puis on a remarqué que les moteurs n'avaient pas le même couple c'est-à-dire, un des moteurs tournait plus vite que l'autre, on a donc dû faire plusieurs tests pour faire tourner les deux moteurs à la même vitesse et ainsi aller tout droit.
 +
 +
=={{Bleu|Plaque pastillée}}==
 +
 +
* Partie 12V
 +
 +
Nous avons alimenté la plaque en 12V grâce à une alimentation.
 +
 +
* Partie 5V
 +
 +
Nous avons branché un abaisseur de tension LM2596 avec en entrée 12V puis avons tourné le potentiomètre à l'aide d'un tournevis pour avoir 5V en sortie. Pour le vérifier, on a utilisé un multimètre.
 +
 +
=Vidéos=
 +
 +
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] <br/ >
 +
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

Version actuelle datée du 18 mars 2021 à 12:15



Présentation du projet

turbo tondeuse


Site Marchand


Objectif

Le projet consiste à fabriquer un robot tondeuse autonome capable d'éviter les obstacles grâce à des capteurs de distance et faire tourner un moteur brushless désignant la lame de la tondeuse.

Tâches individuelles

  • Arel RAKO : 
   * capteur VL53L1X
     - programmé et connecté le capteur

   * moteur brushless 
     - programmé, connecté, fait les soudures nécessaires pour le connecteur de la batterie

   * interrupteur
     - programmé en PULL UP pour faire tourner le moteur à l'état haut et l'arrêter à l'état bas

   * plaque pastillée
     - toutes les soudures de la plaque, qui seront détaillés un peu plus tard
  • Anthony JEAN-BAPTISTE-ADOLPHE :
   * gyroscope MPU9250
    - programmé et connecté le gyroscope

   * capteur VL53L1X
    - programmation pour faire fonctionner 3 capteurs en même temps avec le gyroscope aussi

   * code général
    - programmation

   * différentes soudures

Découpage fonctionnel

découpage fonctionnel

Travail à réaliser

Objectif

L'objectif sera bien évidemment de terminer le projet de sorte qu'il réponde au cahier des charges décrit précédemment.

Pour ce faire, il conviendra de :

- rechercher des solutions à partir du schéma fonctionnel fourni ( schéma électronique et composants )
- dimensionner les composants utilisés
- tester les différents blocs fonctionnels
- programmer les composants
- valider le fonctionnement

Choix des composants

- 3 capteurs de distance VL53L1X
- 1 arduino uno
- 1 shield avec drivers
- 1 gyroscope MPU9250
- 1 batterie EMMERICH 12.8V
- 1 abaisseur de tension LM2596
- 1 moteur brushless
- 1 interrupteur
- 2 moteurs MDP (moteurs des roues)

VL53L1x Arduino Uno MPU9250 LM2596 Moteur Brushless Driver Moteur MDP Interrupteur Batterie

Tondeuse composants.jpg

Explications

Les capteurs de distance

   * connectés en I2C via les ports SCL et SDA de l'arduino 
   * alimentés en 5V via le pin VIN, ils possèdent un régulateur qui transforme le 5V en 2.8V (sortie VDD)
   * placés au côté gauche, droit et au milieu du robot pour avoir un plus grand champ de vision 
   * détails de fonctionnement: 
 
     - si le capteur à gauche détecte un obstacle à moins de 20cm, le robot tourne à droite 
     - si le capteur à droite détecte un obstacle à moins de 20cm, le robot tourne à gauche 
     - si le capteur du milieu détecte un obstacle à moins de 20cm, le robot s'arrête et fait demi-tour vers la droite

Le gyroscope

   * Connecté en I2C comme les capteurs de distance
   * Alimenté en 5V comme les capteurs de distance 
   * Fait la somme de 100 angles et fait leur moyenne pour plus de précision

Moteur Brushless

   * Connecté à un pin PWM de l'Arduino pour pouvoir le piloter
   * Alimenté directement via la batterie car nécessite 12V 
   * Sur le rotor on a mis du scotch pour modéliser la lame

Interrupteur

   * connecté en PULL-UP à un pin quelconque de l'arduino 	
   * alimenté en 5V
   * s'il envoie 1, le moteur brushless commence à tourner, s'il envoie 0, le moteur s'arrête Attention! Prévoir 5 secondes pour l'arrêt du moteur

Abaisseur de tension

   * transforme le 12V de la batterie en 5V pour alimenter les capteurs

Plaque pastillée

   * constituée de 6 parties:
      - le 12V pour alimenter l'arduino, on y branche aussi le connecteur AMASS du moteur brushless et l'abaisseur de tension
      - le 5V où sont connectés tous les capteurs, le gyroscope et l'interrupteur
      - SCL où est connecté le pin SCL des capteurs et du gyroscope au pin SCL de l'arduino
      - SDA où est connecté le pin SDA des capteurs et du gyroscope au pin SDA de l'arduino
      - masse du 12V 
      - masse du 5V

Moteurs MDP

   * Ces moteurs sont pilotés par deux pins, le pin Mx qui permet de définir le sens de rotation du rotor en le mettant à l'état haut ou à l'état bas, puis il y a le pin Ex qui permet de définir la vitesse de rotation du rotor, c'est un pin analogique. On met le pin à 255 pour avoir la vitesse maximale.

Programmation

Code des différents composants

  • programmation des capteurs de distance 
 Bibliothèque  pour le capteur de distance : Bibliothèque

Code distance 

 
 #include <Wire.h>
 #include <VL53L1X.h>

 VL53L1X sensor;   // Déclaration des sensors
 VL53L1X sensor2;
 VL53L1X sensor3;

 //USE_I2C_2V8K;
 void setup()
 {
  pinMode(2, OUTPUT);  // On déclare les pins en sortie
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
   
  digitalWrite(2, LOW);  // On met les sorties à l'état bas pour définir leurs adresses
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  
 // Initialisation I2C
  delay(500);
  Wire.begin();
  Wire.beginTransmission(0x29);
  Serial.begin (9600);

  digitalWrite(3,HIGH);  // On met la sortie à l'état haut pour définir l'adresse de la sortie
  delay(150);
  sensor2.init();  // On initialise le capteur
  Serial.println("01");
  delay(100);
  sensor2.setAddress(0x33); // On définit l'adresse du capteur
  Serial.println("02");

  digitalWrite(4,HIGH); // On met la sortie à l'état haut pour définir l'adresse de la sortie
  delay(150);
  sensor3.init();  // On initialise le capteur
  Serial.println("03");
  delay(100);
  sensor3.setAddress(0x35);  // On définit l'adresse du capteur
  Serial.println("04");

  digitalWrite(2, HIGH);  // On n'a pas besoin de définir l'adresse du premier capteur, il garde son adresse de base
  delay(150);
  Serial.println("09");
  sensor.init();
  Serial.println("10");
  delay(100);

  sensor.setDistanceMode(VL53L1X::Long);  // On définit le mode du capteur
  sensor.setMeasurementTimingBudget(50000);
  sensor.startContinuous(50);
  sensor.setTimeout(100);

  sensor2.setDistanceMode(VL53L1X::Long);  // On définit le mode du capteur
  sensor2.setMeasurementTimingBudget(50000);
  sensor2.startContinuous(50);
  sensor2.setTimeout(100);
  
  sensor3.setDistanceMode(VL53L1X::Long);  // On définit le mode du capteur
  sensor3.setMeasurementTimingBudget(50000);
  sensor3.startContinuous(50);
  sensor3.setTimeout(100);
  
  delay(150);
  Serial.println("addresses set");

  Serial.println ("I2C scanner. Scanning ..."); // C'est un programme pour voir combien et quelles sont adresses des différents composants utilisant l'I2C
  byte count = 0;

  for (byte i = 1; i < 120; i++)
  {

    Wire.beginTransmission (i);
    if (Wire.endTransmission () == 0)
    {
      Serial.print ("Found address: ");
      Serial.print (i, DEC);
      Serial.print (" (0x");
      Serial.print (i, HEX);
      Serial.println (")");
      count++;
      delay (1);
    } // end of good response
  } // end of for loop
  Serial.println ("Done.");
  Serial.print ("Found ");
  Serial.print (count, DEC);
  Serial.println (" device(s).");


 }

 void loop()
 {
  Serial.print("Sensor1: ");  
  Serial.print(sensor.read());  // écrit la distance du capteur 1
  if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
  Serial.println();
  delay(500);
  Serial.print("Sensor2: ");  // écrit la distance du capteur 2
  Serial.print(sensor2.read());
  if (sensor2.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
  Serial.println();
  delay(500);
  Serial.print("Sensor3: ");  // écrit la distance du capteur 3
  Serial.print(sensor3.read());
  if (sensor3.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
  Serial.println();
  delay(500);
 }
  • programmation moteur brushless avec l'interrupteur

Code brushless 

 
const int escPin = 5;  // pin de commande 
int a= digitalRead(13); // pin interrupteur 


void setup() {
  //Init Serial 
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  //Init ESC
  pinMode(escPin, OUTPUT); // on met le pin en sortie pour pouvoir le piloter

}
void loop() {
    

a= digitalRead(13);
Serial.println(a);

if(a<1)
{
 
 Serial.println(a);

}else {
  Serial.println(a);

  digitalWrite(escPin, HIGH); // fait un signal carré qui permet la commutation rapide entre état haut et bas,  ce qui permet de faire tourner le moteur
  delayMicroseconds(1350);
  digitalWrite(escPin, LOW);
  delay(20);
}

}
  • programmation gyroscope
  Bibliothèque du MPU9250 : Bibliothèque

Code gyro 

 
 #include "MPU9250.h"

MPU9250 IMU(Wire,0x68);
int status;



double moyenne;
double moyenneFinal;
int i;


double angle(){
  double Module_magnetic;
  double angle;
  double Xmagnetic;
  double Ymagnetic;
  double Zmagnetic;

  IMU.readSensor();

  Xmagnetic = IMU.getMagX_uT();
  Ymagnetic = IMU.getMagY_uT();
  Zmagnetic = IMU.getMagZ_uT();
  

    
  Module_magnetic = Xmagnetic * Xmagnetic + Ymagnetic * Ymagnetic + Zmagnetic * Zmagnetic; // formule pour définir l'angle en degré
  Module_magnetic = sqrt(Module_magnetic);
  
  angle= atan2(Ymagnetic,Xmagnetic) * (180 / 3.14159265); // angle en degré
  if (angle<0) {angle=angle+360;}
  
  return angle;
}

void setup() {

  Serial.begin(115200);
  while(!Serial) {}

  // début de la communication IMU
  status = IMU.begin();
  if (status < 0) {
    Serial.println("IMU initialization unsuccessful");
    Serial.println("Check IMU wiring or try cycling power");
    Serial.print("Status: ");
    Serial.println(status);
    while(1) {}
  }
  // setting the accelerometer full scale range to +/-8G 
  IMU.setAccelRange(MPU9250::ACCEL_RANGE_8G);
  // setting the gyroscope full scale range to +/-500 deg/s
  IMU.setGyroRange(MPU9250::GYRO_RANGE_500DPS);
  // setting DLPF bandwidth to 20 Hz
  IMU.setDlpfBandwidth(MPU9250::DLPF_BANDWIDTH_20HZ);
  // setting SRD to 19 for a 50 Hz update rate
  IMU.setSrd(19);
}

void loop() {


  //Module du champ

  Serial.print("  "); 
  Serial.print("Angle  ");  //en degré
  Serial.println(angle());


  moyenne = 0;
  for (i=0; i<100; i++) 
  {
    moyenne = moyenne + angle();
    delay(10);

  }
  
  moyenneFinal = moyenne/100;
  Serial.print("Moyenne : ");
  Serial.println(moyenneFinal);
  
  
  // Affiche les différentes valeurs du capteur
  Serial.print("AccelX : ");
  Serial.print(IMU.getAccelX_mss(),6);
  Serial.print("\t");
  Serial.print("AccelY : ");
  Serial.print(IMU.getAccelY_mss(),6);
  Serial.print("\t");
  Serial.print("AccelZ : ");
  Serial.print(IMU.getAccelZ_mss(),6);
  Serial.print("\t");
  Serial.print("GyroX : ");
  Serial.print(IMU.getGyroX_rads(),6);
  Serial.print("\t");
  Serial.print("GyroY : ");
  Serial.print(IMU.getGyroY_rads(),6);
  Serial.print("\t");
  Serial.print("GyroZ : ");
  Serial.print(IMU.getGyroZ_rads(),6);
  Serial.print("\t");
  Serial.print("MagX : ");
  Serial.print(IMU.getMagX_uT(),6);
  Serial.print("\t");
  Serial.print("MagY: ");
  Serial.print(IMU.getMagY_uT(),6);
  Serial.print("\t");
  Serial.print("MagZ : ");
  Serial.print(IMU.getMagZ_uT(),6);
  Serial.print("\n");
  Serial.print("Temp : ");
  Serial.println(IMU.getTemperature_C(),6);
  delay(1000);
  
}
  • programmation moteurs MDP

Code moteurs MDP 

int E1 = 5;     // Moteur droite
int M1 = 4;     
int E2 = 6;     // Moteur gauche
int M2 = 7;


void setup() {

  Serial.println("Initialisation des moteurs...");
  pinMode(M1, OUTPUT);
  pinMode(M2, OUTPUT);
  pinMode(E1, OUTPUT);
  pinMode(E2, OUTPUT);
  Serial.println("Moteurs opérationnels");
}

void loop {

  //mode marche avant (m1 high m2 low)
  //mode marche arrière (m1 low m2 high)
  //tourner à gauche (m1 high m2 high)
  //tourner à droite (m1 low m2 low)
  

    digitalWrite(M1,LOW);
    digitalWrite(M2,HIGH);
    analogWrite(E1, 255);
    analogWrite(E2, 255);
    delay(30);

}

Code général

Code tondeuse 

#include <Arduino.h>
#include <Moteurs.h>
#include <Wire.h>
#include <VL53L1X.h>
#include "MPU9250.h"

int E1 = 5;     // Moteur droite
int M1 = 4;     
int E2 = 6;     // Moteur gauche
int M2 = 7;

int escPin = 5; // Pin de contrôle moteur simulation lame
int a = digitalRead(12);


VL53L1X sensor;  // Déclaration des sensors
VL53L1X sensor2;
VL53L1X sensor3;
MPU9250 IMU(Wire,0x68);

int status;

void setupLaser();  // Déclaration des variable et des fonctions
void setupLame();
void runLame();
void setupMoteurs();
double readGyro();
void setupGyro();
double angle();
void Moteurs();


void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000);
  setupGyro();
  setupLaser();
  setupMoteurs();
  
    
}

void loop(){  
              
  runLame(); // fonction qui fait tourner le moteur de coupe

  // Affiche les différentes valeurs des capteurs
  Serial.print(" Distance 1 : ");
  Serial.print(sensor.read());
  Serial.print(" - Distance 2 : ");
  Serial.print(sensor2.read());
  Serial.print(" - Distance 3 : ");
  Serial.print(sensor3.read());
  Serial.print("\tEtat: ");
  Serial.print(VL53L1X::rangeStatusToString(sensor.ranging_data.range_status));
  Serial.print(" Angle : ");
  Serial.println(angle());

  runLame();

  if((sensor3.read())<=150) //capteur 3 est à droite
  {
    digitalWrite(M1,HIGH); //tourner à gauche
    digitalWrite(M2,HIGH);
    analogWrite(E1, 180);
    analogWrite(E2, 150);
    delay(300);
  }else 
  {
    digitalWrite(M1,HIGH); // marche avant
    digitalWrite(M2,LOW);
    analogWrite(E1, 150);
    analogWrite(E2, 170);
    delay(30);
  }
  runLame();
  if((sensor2.read())<=200) //capteur 2 est devant milieu
  {
    digitalWrite(M1,LOW); // reculer à gauche
    digitalWrite(M2,HIGH);
    analogWrite(E1, 100);
    analogWrite(E2, 200);
    delay(1000);
    digitalWrite(M1,LOW); // arrêt
    digitalWrite(M2,HIGH);
    analogWrite(E1, 0);
    analogWrite(E2, 0);
    delay(1000);
    digitalWrite(M1,HIGH); //marche avant
    digitalWrite(M2,LOW);
    analogWrite(E1, 150);
    analogWrite(E2, 170);
    delay(30);
  }else 
  {
    digitalWrite(M1,HIGH); //marche avant
    digitalWrite(M2,LOW);
    analogWrite(E1, 150);
    analogWrite(E2, 170);
    delay(30);
  }
  runLame();
  if((sensor.read())<=150) //capteur 1 est à gauche
  {
    digitalWrite(M1,LOW); // tourner à droite
    digitalWrite(M2,LOW);
    analogWrite(E1, 150);
    analogWrite(E2, 150);
    delay(300);
  }else 
  {
    digitalWrite(M1,HIGH); // marche avant
    digitalWrite(M2,LOW);
    analogWrite(E1, 150);
    analogWrite(E2, 170);
    delay(30);
  }
  
  runLame();
  
  }

double angle(){
  double angle;
  double Xmagnetic;
  double Ymagnetic;

  IMU.readSensor();

  Xmagnetic = IMU.getMagX_uT();
  Ymagnetic = IMU.getMagY_uT();
  
  angle= atan2(Ymagnetic,Xmagnetic) * (180 / 3.14159265); // angle en degres
  if (angle<0) {angle=angle+360;}
  
  return angle;
}

void setupGyro(){
  Serial.println("Initialisation du Gyroscop...");
    status = IMU.begin();
  if (status < 0) {
    Serial.println("IMU initialization unsuccessful");
    Serial.println("Check IMU wiring or try cycling power");
    Serial.print("Etat: ");
    Serial.println(status);
    Serial.println("Problème avec le Gyroscop");
  }
  // setting the accelerometer full scale range to +/-8G 
  IMU.setAccelRange(MPU9250::ACCEL_RANGE_8G);
  // setting the gyroscope full scale range to +/-500 deg/s
  IMU.setGyroRange(MPU9250::GYRO_RANGE_500DPS);
  // setting DLPF bandwidth to 20 Hz
  IMU.setDlpfBandwidth(MPU9250::DLPF_BANDWIDTH_20HZ);
  // setting SRD to 19 for a 50 Hz update rate
  IMU.setSrd(19);
  Serial.println("Gyroscope opérationnel");
}

double readGyro(){
  double moyenne;
  double moyenneFinal;
  moyenne = 0;
  for (int j =0; j<100; j++) 
  {
    moyenne = moyenne + angle();
    delay(10);

  }
  
  moyenneFinal = moyenne/100;
  return moyenneFinal;
}

void setupLaser(){
  pinMode(2, OUTPUT);  // On déclare les pins en sortie
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  
  digitalWrite(2, LOW);  // On met les sorties à l'état bas pour définir leurs adresses
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);

 // initialise I2C
  delay(500);
  Wire.begin();
  Wire.beginTransmission(0x29);

  digitalWrite(3,HIGH); // On met la sortie à l'état haut pour définir l'adresse de la sortie
  delay(150);
  sensor2.init(); // On initialise le capteur
  Serial.println("01");
  delay(100);
  sensor2.setAddress(0x33); // On définit l'adresse du capteur
  Serial.println("02");

  digitalWrite(4,HIGH); // On met la sortie à l'état haut pour définir l'adresse de la sortie
  delay(150);
  sensor3.init();  // On initialise le capteur
  Serial.println("03");
  delay(100);
  sensor3.setAddress(0x35); // On définit l'adresse du capteur
  Serial.println("04");

  digitalWrite(2, HIGH); // On n'a pas besoin de définir l'adresse du premier capteur, il garde son adresse de base
  delay(150);
  Serial.println("09");
  sensor.init();
  Serial.println("10");
  delay(100);

  sensor.setDistanceMode(VL53L1X::Long);   // On définit le mode du capteur
  sensor.setMeasurementTimingBudget(50000);
  sensor.startContinuous(50);
  sensor.setTimeout(100);

  sensor2.setDistanceMode(VL53L1X::Long);   // On définit le mode du capteur
  sensor2.setMeasurementTimingBudget(50000);
  sensor2.startContinuous(50);
  sensor2.setTimeout(100);
  
  sensor3.setDistanceMode(VL53L1X::Long);   // On définit le mode du capteur
  sensor3.setMeasurementTimingBudget(50000);
  sensor3.startContinuous(50);
  sensor3.setTimeout(100);
  
  delay(150);
  Serial.println("addresses set");

  Serial.println ("I2C scanner. Scanning ...");  // C'est un programme pour voir combien et quelles sont adresses des différents composants utilisant l'I2C
  byte count = 0;


  for (byte i = 1; i < 120; i++)
  {

    Wire.beginTransmission (i);
    if (Wire.endTransmission () == 0)
    {
      Serial.print ("Found address: ");
      Serial.print (i, DEC);
      Serial.print (" (0x");
      Serial.print (i, HEX);
      Serial.println (")");
      count++;
      delay (1);
    } 
  } 
  Serial.println ("Done.");
  Serial.print ("Found ");
  Serial.print (count, DEC);
  Serial.println (" device(s).");
}

void setupMoteurs(){
  Serial.println("Initialisation des moteurs...");
  pinMode(M1, OUTPUT);
  pinMode(M2, OUTPUT);
  pinMode(E1, OUTPUT);
  pinMode(E2, OUTPUT);
  Serial.println("Moteurs opérationnels");
}

void runLame(){
  pinMode (5, OUTPUT);
  pinMode (12, INPUT);

  a= digitalRead(12);
  if(a<1){
       Serial.println(a);

  }
  else {
    
       Serial.println(a);

  digitalWrite(escPin, HIGH);  // fait un signal carré qui permet la commutation rapide entre état haut et bas,  ce qui permet de faire tourner le moteur
  delayMicroseconds(1350);
  digitalWrite(escPin, LOW);
  delay(20);
      }  
}


void Moteurs()
{
  
  //mode marche avant (m1 high m2 low)
  //mode marche arrière (m1 low m2 high)
  //tourner à gauche (m1 high m2 high)
  //tourner à droite (m1 low m2 low)
  

    digitalWrite(M1,LOW);
    digitalWrite(M2,HIGH);
    analogWrite(E1, 255);
    analogWrite(E2, 255);
    delay(30);

}

// End of file

Tests réalisés

Capteurs de distance

  • Nous avons connecté un seul capteur pour commencer sur une platine à essai avec un arduino uno avec le programme fourni par le constructeur, et avons vérifié que le capteur

nous donne une valeur correcte. Nous avons ensuite connecté les 3 capteurs en série sur la platine d'essai toujours, et avons vérifié qu'ils affichaient une valeur différente grâce à leur différente adresse.

Gyroscope

  • On a testé le code du gyroscope avec le capteur seul sur une platine d'essai, le code a été trouvé sur internet. Le code fonctionnait bien, on avait les valeurs de la magnitude en X, Y et Z. Pareil pour l'accélération et on avait aussi la température. Puis on a programmé un code permettant de faire une boussole pour avoir l'angle par rapport au nord magnétique. Ensuite on a mis en commun avec les capteurs de distance, il n'y a pas besoin de redéfinir son adresse vu qu'elle est déjà différente des capteurs de distance.

Moteur brushless

  • Nous avons testé plusieurs codes qui permettaient de faire tourner le moteur mais aucun ne le faisait tourner en continu. Pour ce faire, nous avons modifié un code qui permettait de faire du RUN / STOP pendant un certain temps fixé. (voir ci-contre)

Code pour RUN / STOP 

//Parameters
const int escPin = 3;
int min_throttle = 1000;
int max_throttle = 2000;
unsigned long currentMillis, previousMillis;

void setup() {
//Init Serial USB
Serial.begin(9600);
Serial.println(F("Initialize System"));
//Init ESC
pinMode(escPin, OUTPUT);
initProcedure();
}
void loop() {
  runBrushless();

}
void runBrushless() {
Serial.println("running");
currentMillis = 0;
previousMillis = millis();
while (currentMillis < 2000) {
currentMillis = millis() - previousMillis;
digitalWrite(escPin, HIGH);
delayMicroseconds(1350);
digitalWrite(escPin, LOW);
delay(20);
}
Serial.println("stop");
currentMillis = 0;
previousMillis = millis();
while (currentMillis < 2000) {
currentMillis = millis() - previousMillis;
digitalWrite(escPin, HIGH);
 delayMicroseconds(min_throttle);
 digitalWrite(escPin, LOW);
 delay(20);
}
}
void initProcedure() {
previousMillis = millis();
Serial.println("throttle up");
while (currentMillis < 3000) {
currentMillis = millis() - previousMillis;
 Serial.println(currentMillis);
 digitalWrite(escPin, HIGH);
 delayMicroseconds(max_throttle);
 digitalWrite(escPin, LOW);
 delay(20);
}
currentMillis = 0;
previousMillis = millis();
Serial.println("throttle down");
while (currentMillis < 4500) {
currentMillis = millis() - previousMillis;
 Serial.println(currentMillis);
 digitalWrite(escPin, HIGH);
 delayMicroseconds(min_throttle);
 digitalWrite(escPin, LOW);
 delay(20);
}
}

Moteurs MDP

On a testé les moteurs en mettant le pin M1 du moteur de droite à l'état haut et le pin M2 à l'état haut et les pins E1 et E2 à 255, on a vu que le robot tournait à gauche. Ainsi on a testé toutes les possibilités, cela nous a permis de définir la marche avant, la marche arrière, tourner à gauche et à droite. Puis on a remarqué que les moteurs n'avaient pas le même couple c'est-à-dire, un des moteurs tournait plus vite que l'autre, on a donc dû faire plusieurs tests pour faire tourner les deux moteurs à la même vitesse et ainsi aller tout droit.

Plaque pastillée

  • Partie 12V
Nous avons alimenté la plaque en 12V grâce à une alimentation.
  • Partie 5V
Nous avons branché un abaisseur de tension LM2596 avec en entrée 12V puis avons tourné le potentiomètre à l'aide d'un tournevis pour avoir 5V en sortie. Pour le vérifier, on a utilisé un multimètre.

Vidéos

Vidéo de démonstration du robot qui roule
Vidéo du moteur de coupe

Récupérée de « http://wikigeii.iut-troyes.univ-reims.fr//index.php?title=RobotTondeuse&oldid=14455 »