troyesGEII - Contributions de l’utilisateur [fr]

RobotTondeuse

2021-03-18T11:15:36Z

Tondeuse : /* {{Bleu|Code des différents composants}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-18T11:14:38Z

Tondeuse : /* {{Bleu|Programmation}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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/lien 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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-18T11:13:34Z

Tondeuse : /* {{Bleu|Code des différents composants}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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|lien 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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:53:59Z

Tondeuse : /* {{Vert|Github}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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/lien 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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:53:10Z

Tondeuse : /* {{Bleu|Programmation}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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/lien 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}}

==={{Vert|Github}}===

Voici un lien qui condense tous les codes et bibliothèque de notre projet [https://github.com/Wasabules/Projet-Tondeuse/lien github]

= 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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:35:48Z

Tondeuse : /* {{Bleu|Moteurs MDP}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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/lien 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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:30:12Z

Tondeuse : /* {{Bleu|Moteurs MDP}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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/lien 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 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 a 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'avait pas le même couple donc un des moteurs tournait plus vite que l'autre alors on a du 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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:22:23Z

Tondeuse : /* {{Bleu|Plaque pastillée}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:21:56Z

Tondeuse : /* {{Bleu|Code général}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:21:33Z

Tondeuse : /* {{Bleu|Code des différents composants}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:20:54Z

Tondeuse : /* {{Bleu|Code des différents composants}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:20:27Z

Tondeuse : /* Moteurs MDP */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:16:17Z

Tondeuse : /* Moteurs MDP */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

* Pour ces moteurs ils sont pilotés par deux pins, le pin Mx 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 a 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:15:51Z

Tondeuse : /* {{Bleu|Explications}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

* Pour ces moteurs ils sont pilotés par deux pins, le pin Mx 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 a 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:15:21Z

Tondeuse : /* Plaque pastillée */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

* Pour ces moteurs ils sont pilotés par deux pins, le pin Mx 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 a 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:15:07Z

Tondeuse : /* Plaque pastillée */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

* Pour ces moteurs ils sont pilotés par deux pins, le pin Mx 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 a 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:14:16Z

Tondeuse : /* Moteurs MDP */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

* Pour ces moteurs ils sont pilotés par deux pins, le pin Mx 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 a 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:13:59Z

Tondeuse : /* Plaque pastillée */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

* Pour ces moteurs ils sont pilotés par deux pins, le pin Mx 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 a 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:13:37Z

Tondeuse : /* Plaque pastillée */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

* Pour ces moteurs ils sont pilotés par deux pins, le pin Mx 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 a 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:13:14Z

Tondeuse : /* Plaque pastillée */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

* Pour ces moteurs ils sont pilotés par deux pins, le pin Mx 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 a 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:12:35Z

Tondeuse : /* Plaque pastillée */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

* Pour ces moteurs ils sont pilotés par deux pins, le pin Mx 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 a 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:12:12Z

Tondeuse : /* Moteurs MDP */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

* Pour ces moteurs ils sont pilotés par deux pins, le pin Mx 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 a 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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:06:27Z

Tondeuse : /* Moteur brushless */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

=={{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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:05:56Z

Tondeuse : /* Le gyroscope */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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 ===

=={{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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:05:10Z

Tondeuse : /* {{Bleu|Vidéos}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}==

=={{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] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:04:38Z

Tondeuse :

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}==

=={{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.

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-16T08:03:41Z

Tondeuse : /* {{Bleu|Vidéos}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}==

=={{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.

RobotTondeuse

2021-03-16T08:03:15Z

Tondeuse : /* {{Bleu|Capteurs de distance}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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.

RobotTondeuse

2021-03-16T08:02:56Z

Tondeuse : /* {{Bleu|Moteur brushless}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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.

RobotTondeuse

2021-03-16T08:02:39Z

Tondeuse : /* {{Bleu|Moteur brushless}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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.

RobotTondeuse

2021-03-16T08:02:25Z

Tondeuse : /* {{Bleu|Moteur brushless}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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.

RobotTondeuse

2021-03-16T08:01:48Z

Tondeuse : /* {{Bleu|Moteur brushless}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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.

RobotTondeuse

2021-03-16T08:00:59Z

Tondeuse : /* {{Bleu|Gyroscope}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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.

RobotTondeuse

2021-03-16T07:39:53Z

Tondeuse : /* {{Bleu|Explications}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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}}==

=={{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.

RobotTondeuse

2021-03-16T07:39:27Z

Tondeuse : /* {{Bleu|Explications}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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}}==

=={{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.

RobotTondeuse

2021-03-16T07:38:19Z

Tondeuse : /* {{Bleu|Explications}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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}}==

=={{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.

RobotTondeuse

2021-03-16T07:35:20Z

Tondeuse : /* {{Bleu|Explications}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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 ===

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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}}==

=={{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.

RobotTondeuse

2021-03-16T07:33:48Z

Tondeuse : /* {{Bleu|Explications}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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}}==

=={{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.

RobotTondeuse

2021-03-16T07:31:58Z

Tondeuse : /* {{Bleu|Plaque pastillée}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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}}==

=={{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.

RobotTondeuse

2021-03-16T07:26:58Z

Tondeuse : /* {{Bleu|Moteur brushless}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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}}==

=={{Bleu|Plaque pastillée}}==

RobotTondeuse

2021-03-16T07:23:33Z

Tondeuse : /* Tests réalisés */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= 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}}==

=={{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)

=={{Bleu|Moteurs MDP}}==

=={{Bleu|Plaque pastillée}}==

RobotTondeuse

2021-03-16T07:10:46Z

Tondeuse : /* Travail à réaliser */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

= Tests réalisés =

RobotTondeuse

2021-03-15T15:10:03Z

Tondeuse : /* {{Bleu|Code général}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-15T15:01:24Z

Tondeuse :

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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;
VL53L1X sensor2;
VL53L1X sensor3;
MPU9250 IMU(Wire,0x68);

int status;

void setupLaser();
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();
//setupLame();

}

void loop(){

runLame();

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);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);

digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);

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

digitalWrite(3,HIGH);
delay(150);
sensor2.init();
Serial.println("01");
delay(100);
sensor2.setAddress(0x33);
Serial.println("02");

digitalWrite(4,HIGH);
delay(150);
sensor3.init();
Serial.println("03");
delay(100);
sensor3.setAddress(0x35);
Serial.println("04");

digitalWrite(2, HIGH);
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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-15T14:58:53Z

Tondeuse : /* {{Bleu|Tâches individuelles}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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

=={{Bleu|Découpage fonctionnel}}==

[[Fichier:tondeuse_fonctions.jpg|600px||découpage fonctionnel]]

= Travail à réaliser =

=={{Bleu|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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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;
VL53L1X sensor2;
VL53L1X sensor3;
MPU9250 IMU(Wire,0x68);

int status;

void setupLaser();
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();
//setupLame();

}

void loop(){

runLame();

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);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);

digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);

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

digitalWrite(3,HIGH);
delay(150);
sensor2.init();
Serial.println("01");
delay(100);
sensor2.setAddress(0x33);
Serial.println("02");

digitalWrite(4,HIGH);
delay(150);
sensor3.init();
Serial.println("03");
delay(100);
sensor3.setAddress(0x35);
Serial.println("04");

digitalWrite(2, HIGH);
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 ...");
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);
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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-15T14:58:19Z

Tondeuse :

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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 au niveau haut et l'arrêter au niveau 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}}==

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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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;
VL53L1X sensor2;
VL53L1X sensor3;
MPU9250 IMU(Wire,0x68);

int status;

void setupLaser();
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();
//setupLame();

}

void loop(){

runLame();

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);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);

digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);

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

digitalWrite(3,HIGH);
delay(150);
sensor2.init();
Serial.println("01");
delay(100);
sensor2.setAddress(0x33);
Serial.println("02");

digitalWrite(4,HIGH);
delay(150);
sensor3.init();
Serial.println("03");
delay(100);
sensor3.setAddress(0x35);
Serial.println("04");

digitalWrite(2, HIGH);
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 ...");
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);
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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-15T14:57:29Z

Tondeuse :

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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 au niveau haut et l'arrêter au niveau 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}}==

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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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;
VL53L1X sensor2;
VL53L1X sensor3;
MPU9250 IMU(Wire,0x68);

int status;

void setupLaser();
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();
//setupLame();

}

void loop(){

runLame();

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);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);

digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);

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

digitalWrite(3,HIGH);
delay(150);
sensor2.init();
Serial.println("01");
delay(100);
sensor2.setAddress(0x33);
Serial.println("02");

digitalWrite(4,HIGH);
delay(150);
sensor3.init();
Serial.println("03");
delay(100);
sensor3.setAddress(0x35);
Serial.println("04");

digitalWrite(2, HIGH);
delay(150);
Serial.println("09");
sensor.init();
Serial.println("10");
delay(100);

sensor.setDistanceMode(VL53L1X::Long);
sensor.setMeasurementTimingBudget(50000);
sensor.startContinuous(50);
sensor.setTimeout(100);

sensor2.setDistanceMode(VL53L1X::Long);
sensor2.setMeasurementTimingBudget(50000);
sensor2.startContinuous(50);
sensor2.setTimeout(100);

sensor3.setDistanceMode(VL53L1X::Long);
sensor3.setMeasurementTimingBudget(50000);
sensor3.startContinuous(50);
sensor3.setTimeout(100);

delay(150);
Serial.println("addresses set");

Serial.println ("I2C scanner. Scanning ...");
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);
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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-15T14:40:15Z

Tondeuse : /* {{Bleu|Code des différents composants}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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 au niveau haut et l'arrêter au niveau 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}}==

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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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;
VL53L1X sensor2;
VL53L1X sensor3;
MPU9250 IMU(Wire,0x68);

int status;

void setupLaser();
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();
//setupLame();

}

void loop(){

runLame();

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);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);

digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);

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

digitalWrite(3,HIGH);
delay(150);
sensor2.init();
Serial.println("01");
delay(100);
sensor2.setAddress(0x33);
Serial.println("02");

digitalWrite(4,HIGH);
delay(150);
sensor3.init();
Serial.println("03");
delay(100);
sensor3.setAddress(0x35);
Serial.println("04");

digitalWrite(2, HIGH);
delay(150);
Serial.println("09");
sensor.init();
Serial.println("10");
delay(100);

sensor.setDistanceMode(VL53L1X::Long);
sensor.setMeasurementTimingBudget(50000);
sensor.startContinuous(50);
sensor.setTimeout(100);

sensor2.setDistanceMode(VL53L1X::Long);
sensor2.setMeasurementTimingBudget(50000);
sensor2.startContinuous(50);
sensor2.setTimeout(100);

sensor3.setDistanceMode(VL53L1X::Long);
sensor3.setMeasurementTimingBudget(50000);
sensor3.startContinuous(50);
sensor3.setTimeout(100);

delay(150);
Serial.println("addresses set");

Serial.println ("I2C scanner. Scanning ...");
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);
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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-15T14:36:29Z

Tondeuse : /* {{Bleu|Code des différents composants}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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 au niveau haut et l'arrêter au niveau 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}}==

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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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 = 3;
int a= digitalRead(13);

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

}
void loop() {

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

if(a<1)
{

Serial.println(a);

}else {
Serial.println(a);

digitalWrite(escPin, HIGH);
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;
VL53L1X sensor2;
VL53L1X sensor3;
MPU9250 IMU(Wire,0x68);

int status;

void setupLaser();
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();
//setupLame();

}

void loop(){

runLame();

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);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);

digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);

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

digitalWrite(3,HIGH);
delay(150);
sensor2.init();
Serial.println("01");
delay(100);
sensor2.setAddress(0x33);
Serial.println("02");

digitalWrite(4,HIGH);
delay(150);
sensor3.init();
Serial.println("03");
delay(100);
sensor3.setAddress(0x35);
Serial.println("04");

digitalWrite(2, HIGH);
delay(150);
Serial.println("09");
sensor.init();
Serial.println("10");
delay(100);

sensor.setDistanceMode(VL53L1X::Long);
sensor.setMeasurementTimingBudget(50000);
sensor.startContinuous(50);
sensor.setTimeout(100);

sensor2.setDistanceMode(VL53L1X::Long);
sensor2.setMeasurementTimingBudget(50000);
sensor2.startContinuous(50);
sensor2.setTimeout(100);

sensor3.setDistanceMode(VL53L1X::Long);
sensor3.setMeasurementTimingBudget(50000);
sensor3.startContinuous(50);
sensor3.setTimeout(100);

delay(150);
Serial.println("addresses set");

Serial.println ("I2C scanner. Scanning ...");
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);
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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]

RobotTondeuse

2021-03-15T14:33:33Z

Tondeuse : /* {{Bleu|Code des différents composants}} */

[[Catégorie:Projets]]

=Présentation du projet=

[[Fichier:Photo tondeuse autonome.png|500px||turbo tondeuse]] 

[https://www.husqvarna.com/fr/produits/robots-tondeuses/ Site Marchand]

=={{Bleu|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. 

=={{Bleu|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 au niveau haut et l'arrêter au niveau 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}}==

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 

=={{Bleu|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) 

[[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: 
- 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
* prend la valeur 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

=={{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/lien 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 = 3;
int a= digitalRead(13);

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

}
void loop() {

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

if(a<1)
{

Serial.println(a);

}else {
Serial.println(a);

digitalWrite(escPin, HIGH);
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);

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;
VL53L1X sensor2;
VL53L1X sensor3;
MPU9250 IMU(Wire,0x68);

int status;

void setupLaser();
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();
//setupLame();

}

void loop(){

runLame();

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);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);

digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);

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

digitalWrite(3,HIGH);
delay(150);
sensor2.init();
Serial.println("01");
delay(100);
sensor2.setAddress(0x33);
Serial.println("02");

digitalWrite(4,HIGH);
delay(150);
sensor3.init();
Serial.println("03");
delay(100);
sensor3.setAddress(0x35);
Serial.println("04");

digitalWrite(2, HIGH);
delay(150);
Serial.println("09");
sensor.init();
Serial.println("10");
delay(100);

sensor.setDistanceMode(VL53L1X::Long);
sensor.setMeasurementTimingBudget(50000);
sensor.startContinuous(50);
sensor.setTimeout(100);

sensor2.setDistanceMode(VL53L1X::Long);
sensor2.setMeasurementTimingBudget(50000);
sensor2.startContinuous(50);
sensor2.setTimeout(100);

sensor3.setDistanceMode(VL53L1X::Long);
sensor3.setMeasurementTimingBudget(50000);
sensor3.startContinuous(50);
sensor3.setTimeout(100);

delay(150);
Serial.println("addresses set");

Serial.println ("I2C scanner. Scanning ...");
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);
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}}

=={{Bleu|Vidéos}}==
[https://www.youtube.com/watch?v=N13t8mgYYdE&ab_channel=AnthonyJeanBaptisteAdolphe/ Vidéo de démonstration du robot qui roule] 
[https://youtu.be/lpB92UMG2C8/ Vidéo du moteur de coupe]