troyesGEII - Contributions de l’utilisateur [fr]

Robotique2 2

2021-04-07T11:03:47Z

Robotique2 2 :

[[Catégorie:Projets]]

=Présentation du projet=

Le but du robot est d’envoyer un maximum de balle dans le camp adverse sans jamais y entrer et sans contrôler plus d’une balle à la fois. 
Les parties se dérouleront sur un terrain de 8 mètres par 4, divisé en deux parties par une ligne blanche centrale de 67cm de large donc notre robot aura une surface de 4 mètres par 4, soit 16m² pour se déplacer. 
Les parties auront une durée de 90 secondes à l’issu desquelles notre robot devra se déplacer jusqu'à la ligne blanche centrale, sans pour autant la dépasser, puis arrêter ses moteurs et crever le ballon qui sera accroché à son socle, à 30cm du sol minimum. 
Notre robot devra être totalement autonome et en aucun cas ne pourra être téléopéré. 
Nous devons toutefois faire face à quelques obligations : 

Aucune tension ne doit dépasser 24V. 
Le robot ne peut avoir que 2 roues motrices. 
La distance entre ces 2 roues doit être inférieure à 30 cm. 
La batterie ne doit être ni au lithium-polymère, ni au lithium-cobalts. 
Le propulseur de balle ne doit sortir du robot uniquement pour un tir, et doit revenir se ranger lorsque son tir est terminé. 

Pour se faire, nous avons séparer les différentes parties sous la forme suivante : 
Lachiri Iyad : Caméra Pixy2, Boussole & création physique. 
Sciré Morgane : Crève-ballon & pièces 3D. 
Mathieu Anthony : Fonction frapper la balle & la retenir 
Garnier Clément : Détecter les lignes & créer un compte à rebours 
Lescasse Enzo : Fonction se déplacer & mise en commun des différents programmes 

=Fonctionnement du robot=

[[Fichier:Capture d’écran 2021-03-09 10-21-10.png|vignette]]

Le fonctionnement du robot devra se dérouler comme ci-contre exactement (voir image du diagramme de fonctionnement), lors de ce compte-rendu, nous détaillerons donc les actions dans l'ordre où elles interviendront sur le fonctionnement du robot. 

==Caméra Pixy2, Boussole & création physique==

La caméra Pixy2 se branche seulement sur le port ICSP d'une carte Arduino Uno en l'occurence. 
Peu de montage physique entraîne beaucoup de programmation, nous avons donc conçu ce programme afin de faire fonctionner la caméra : 

{{boîte déroulante/début|titre=Code_Pixy2}}
<source lang=c>
#include <Pixy2.h>
Pixy2 pixy;
void setup()
{
Serial.begin(115200);
Serial.print("Starting...\n");
pixy.init();
}
void loop()
{
int i;
int x;
int y;
pixy.ccc.getBlocks();
if (pixy.ccc.numBlocks) // si on détecte la balle
{
Serial.print("position x de la balle ");
Serial.print(i);
Serial.print(": ");
Serial.println(pixy.ccc.blocks[i].m_x); // on indique la position de la balle sur l'axe x (entre 316 et 0)
if (pixy.ccc.blocks[i].m_x < 103) { // si la balle est plus à gauche par rapport au milieu de l'axe, on tourne à gauche
Serial.println("tourner à gauche");
}
if (pixy.ccc.blocks[i].m_x > 206) {
Serial.println("tourner à droite"); // si la balle est plus à droite par rapport au milieu de l'axe, on tourne à droite
}
Serial.print("position y de la balle ");
Serial.print(i);
Serial.print(": ");
Serial.println(pixy.ccc.blocks[i].m_y);
if (pixy.ccc.blocks[i].m_y > 105 && pixy.ccc.blocks[i].m_x < 206 && pixy.ccc.blocks[i].m_x > 103) { // si la balle est en face du robot, et proche
Serial.println("avancer doucement");
}
if (pixy.ccc.blocks[i].m_y < 105 && pixy.ccc.blocks[i].m_x < 206 && pixy.ccc.blocks[i].m_x > 103) {// si la balle au centre de l’axe X, et loin du robot
Serial.println("avancer rapidement");
}
}
//si on ne détecte pas la balle
else {
Serial.println("chercher la balle");
}
delay(1000);
}
</source>
{{boîte déroulante/fin}}

Afin de pouvoir régler la caméra Pixy lors de sa programmation, nous avons eu recours au logiciel "PixyMon" qui nous permet d'afficher sur l'écran d'ordinateur ce que la caméra voit en temps réel :

<gallery>
Pixy2.jpg|Caméra Pixy2
VisuelPixy2.jpg|PixyMon

</gallery>

==Crève-ballon & pièces 3D==

[[Fichier:Crève-ballon.png|vignette]]

Tout d'abord, il fallait trouver comment fixer à 30 cm minimum du sol et comment maintenir le ballon sur le robot. On a donc crée un socle en 3D pour maintenir le ballon afin qu'il soit maintenu et qu'il ne bouge pas trop lors du déplacement du robot sur le terrain. 

Ensuite, pour exploser le ballon, on utilisera un pique car c'est une solution simple et efficace à mettre en œuvre. Sachant que pour percer un ballon à l'aide d'un pique nous n’avons pas besoin de beaucoup de force, on a décidé d'utiliser un servomoteur. 

Le pique sera fixé sur un bras conçu en 3D, une partie du bras sera fixé sur le servomoteur et sur l'autre extrémité il y aura le pique. Le servomoteur s'utilise en degrés, c'est-à-dire qu'il peut tourner de 0 à 180°. On le mettra en position initiale, c'est-à-dire à 0° et on le programme de façon à ce qu'il puisse exploser le ballon, donc ici il devra tourner d'environ 140° pour exploser le ballon et ensuite se remettre dans sa position initiale. 

Après avoir trouver et tester cette solution, il fallait trouver comment fixer le servomoteur le plus proche possible du ballon. On a donc décidé de le fixer sur le socle du ballon. 
On a donc crée une pièce 3D qui se fixe autour du socle à l'aide d'une "bague" sur laquelle on y a mis une encoche pour y insérer le servomoteur.

{{boîte déroulante/début|titre=Code_Crève Ballon}}
<source lang=c>
#include <Servo.h>

Servo monServomoteur; //Création de l’objet servomoteur

void setup() {

monServomoteur.attach(7); // Déclaration pour utilisation de la broche 7
monServomoteur.write(0); // Initialisation de la position 0
Serial.begin(9600);
}

void loop() {

monServomoteur.write(130);
delay(0000);

monServomoteur.write(0);
delay(0000);

}
</source>
{{boîte déroulante/fin}}

==Fonction frapper la balle & la retenir==

La fonction qui permet d'attraper la balle de tennis et de la frapper est la partie du robot qui nous permettra de marquer des points sur le terrain ou non. 

Pour cette partie, énormément d'idées ont vu le jour :
- Utilisation de moteur à courant continu
- Utilisation de moteurs pas-à-pas
- Utilisation de ressorts ou de lames de ressorts

La solution retenue pour la version finale est l'utilisation des différentes parties du robot, de deux servomoteurs ( un pour attraper la balle et un autre pour la projeter ), et d'un HC SR 04 qui permet un calcul de distance à l'aider d'ultrason qui contrôlera la présence ou non de la balle dans la zone des 2 servomoteurs. 
Le fonctionnement et le déroulement se feront en six étapes : 

- A l'aide de la caméra Pixy2, le robot se dirige vers la balle
- Une fois que le capteur de distance HCSR04 détectera la présence de la balle, le servomoteur qui permet de contenir la balle va se refermer sur celle-ci pour l'attraper
''La balle sera alors contenue entre les deux servomoteurs, celui qui sert à attraper, et celui qui est prêt à la frapper à tout moment''
- A l'aide du gyroscope, le robot va se diriger vers le terrain adverse
- Une fois sur la ligne blanche, celle-ci sera détectée grâce au capteur de ligne et le robot va mettre ses moteurs à 0 afin d'arrêter totalement le mouvement
- Enfin, le robot ouvrira le bras du servomoteur qui servait à contenir la balle, et va actionner le second servomoteur afin de pousser la balle dans le camp adverse. 
Cette partie est donc l'une des plus importantes car elle regroupe toutes les autres parties et nous permet de marquer des points.

{{boîte déroulante/début|titre=Code_Frapper la balle}}
<source lang=c>
#include <Servo.h>
int capteur0;
int capteur1;
int capteur2;

Servo monServomoteurTaper;
const int detecte = 8;

void setup() {

pinMode(detecte, INPUT); //detecte balle
monServomoteurTaper.attach(8);
monServomoteurTaper.write(0);

Serial.begin(9600);
}

void loop() {

int sensorValue0 = analogRead(A0);
int sensorValue1 = analogRead(A1);
int sensorValue2 = analogRead(A2);
Serial.println("capteur0");
Serial.println(sensorValue0);
//delay(1000);
Serial.println("capteur1");
Serial.println(sensorValue1);
//delay(1000);
Serial.println("capteur2");
Serial.println(sensorValue2);
//delay(1000);
if ((sensorValue0 > 500) && (sensorValue1 > 400) && (sensorValue2 > 200))
{
Serial.println("ARRET MOTEUR");
monServomoteurTaper.write(90);
}
else if ((sensorValue0 < 450) && (sensorValue1 < 400) && (sensorValue2 < 200))
{

monServomoteurTaper.write(0);

}
}
</source>
{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=Code_Attraper la balle}}
<source lang=c>
#include <Servo.h>

Servo monServomoteurAttraper;

int trig = 2;
int echo = 3;
long lecture_echo;
long cm;

void setup() {
monServomoteurAttraper.attach(7);
monServomoteurAttraper.write(0);

pinMode(trig, OUTPUT);
digitalWrite(trig, LOW);
pinMode(echo, INPUT);
Serial.begin(9600);

}

void loop() {

digitalWrite(trig, HIGH);
delayMicroseconds(10);
digitalWrite(trig, LOW);
lecture_echo = pulseIn(echo, HIGH);
cm = lecture_echo / 58;
Serial.print("Distance en cm :");
Serial.println(cm);
delay(500);

if (cm < 5)
{

Serial.print("Balle attrapée");
monServomoteurAttraper.write(90);
delay(100);

}
if (cm > 5){
Serial.print("Balle va être attrapée");
monServomoteurAttraper.write(0);
delay(100);
}
}
</source>
{{boîte déroulante/fin}}

==Détecter les lignes & créer un compte à rebours==
[[Fichier:PieceCny70.png|100px]]

Pour la partie détection de ligne nous avons décidé d'utiliser 6 capteurs Cny70 répartis sur l’avant du robot.
Nous avons utilisé ce schéma de branchement pour les 6 capteurs et nous les avons reliés ensemble. 
Le CNY70 est un émetteur et un récepteur infrarouge. 
Le capteur envoie un faisceau infrarouge et selon la luminosité reçue, la tension dans le capteur variera, grâce à cette tension nous pourrons savoir si le capteur est sur la ligne blanche ou sur le terrain bleu. 
Pour détecter la ligne blanche au milieu du terrain. Nous les avons regroupés par 3 afin qu’ils couvrent une plus grande surface de détection. Et si les 6 capteurs possèdent la même tension correspondant à la ligne blanche alors le robot s’arrêtera.
Tout ce programme sera regroupé au sein du code du TIMER qui permettra au robot de s'arrêter avant la fin du temps imparti.

{{boîte déroulante/début|titre=Code_Détecteur de ligne}}
<source lang=c>
void setup()
{
pinMode(A0, INPUT);
pinMode(A1, INPUT);
pinMode(A2, INPUT);

Serial.begin(9600);
}

void loop()
{
//on declare les variables des capteurs
int capteur0;
int capteur1;
int capteur2;
//On declare les variables sensorValue
//pour donné un nom a la valeur que donnera la pin
int sensorValue0 = analogRead(A0);
int sensorValue1 = analogRead(A1);
int sensorValue2 = analogRead(A2);
//Serial.println("capteur0");
//Serial.println(sensorValue0);
//delay(1000);
//Serial.println("capteur1");
//Serial.println(sensorValue1);
//delay(1000);
//Serial.println("capteur2");
//Serial.println(sensorValue2);
//delay(1000);

if ((sensorValue0 < 240))
{
capteur0 = 1;
Serial.print(capteur0);
Serial.println("___capteur dans le bleu");
delay(1000);

}
else if ((sensorValue0 > 240))
{
capteur0 = 2;
Serial.print( capteur0);
Serial.println("___capteur dans le blanc");
delay(1000);
}

if ((sensorValue1 < 240))
{
capteur1 = 11;
Serial.print(capteur1);
Serial.println("___capteur dans le bleu");
delay(1000);
}
else if ((sensorValue1 > 240))
{
capteur1 = 12;
Serial.print( capteur1);
Serial.println("___capteur dans le blanc");
delay(1000);
}

if ((sensorValue2 < 250))
{
capteur2 = 21;
Serial.print(capteur2);
Serial.println("___capteur dans le bleu");
delay(1000);
}
else if ((sensorValue2 > 250))
{
capteur2 = 22;
Serial.print( capteur2);
Serial.println("___capteur dans le blanc");
delay(1000);
}
if ((sensorValue0 > "") && (sensorValue1 > "") && (sensorValue2 > ""))
{
Serial.println("ARRET MOTEUR");
}
}
</source>
{{boîte déroulante/fin}}

[[Fichier:FonctionnementCny70.png|200px]]

==Fonction se déplacer==

Pour créer cette fonction, nous avons pris deux moteurs en courant continu, un shield moteur L298P ainsi qu'une batterie de 12V. 
Pour le programme, j’ai commencé par déclarer les variables et faire le void setup, ensuite pour le void loop, j’ai préparé les 5 actions nécessaires soit : avancer lentement et rapidement, tourner à gauche et à droite et chercher la balle. Lorsqu’il faut tourner à gauche, on active les deux moteurs mais le moteur de droite va être plus rapide que celui de gauche ce qui permettra une rotation du robot, inversement pour tourner à droite.
Pour avancer plus ou moins rapidement, on active tout simplement les deux moteurs plus ou moins vite, et pour chercher la balle, on exerce le même programme que pour tourner à gauche ce qui va permettre au robot de subir une rotation jusqu’à ce qu’une balle entre dans son champs de vision.

{{boîte déroulante/début|titre=Code_SeDéplacer}}
<source lang=c>
int E1 = 5;
int M1 = 4;
int E2 = 6;
int M2 = 7;
void setup()
{
pinMode(M1, OUTPUT);
pinMode(M2, OUTPUT);
}
void loop()
{
if (){ // si la balle est plus à gauche que la barre verticale des ⅓ de pixel
Serial.println("tourner à gauche");
analogWrite(E1, 30);
analogWrite(E2, 50);
}
if () {// si la balle est plus à droite que la barre des ⅔ de pixel
Serial.println("tourner à droite");
analogWrite(E1, 50);
analogWrite(E2, 30);
}
if (){ // si la balle est, sur l’axe y, supérieur à la moitié
Serial.println("avancer doucement");
analogWr+ Boussole +ite(E1, 50);
analogWrite(E2, 50);
}
if (){ // si la balle est inférieur à la moitié sur l’axe y
Serial.println("avancer rapidement"); // si la balle est plus à droite par rapport au milieu de l'axe, on tourne à droite
analogWrite(E1, 100);
analogWrite(E2, 100);
}
}
//si on ne détecte pas la balle
else {
Serial.println("chercher la balle");
analogWrite(E1, 50);
analogWrite(E2, 30);
}
}
</source>
{{boîte déroulante/fin}}

Pour le programme final, nous avons changé la variable pour tourner, c’est-à-dire qu'au lie de tourner à une vitesse constante et e risquer de passer devant la balle sans avoir le temps de la voir, nous avons créé une équation qui nous permettra de faire fluctuer la vitesse en fonction de l'angle entre la balle et le centre de vision du robot. 
Nous avons donc obtenu cette équation : 
analogWrite(E1, (N + K * (pixy.ccc.blocks[i].m_x - 158))); // N est une vitesse constante, K un coefficient réducteur, puis on soustrait la position X de la balle par le nombre de pixels central de la vision afin d'obtenir un angle. 
''Cette équation n'est valable que pour tourner à droite, pour tourner à gauche nous remplacerons les parenthèses par 158 - position X de la balle.''

Le robot ralentira sa rotation au fur et à mesure que la balle se rapprochera du centre de sa vision jusqu'à aller finalement tout droit et réussir à l'intercepter.

=Mise en commun des différents programmes=

Lors de cette partie, nous allons vous expliquer, étape par étape, comment nous avons mit nos codes en commun chacun notre tour jusqu'à obtenir le code final.
Au niveau de la construction physique du robot, nous nous sommes débrouillé pour que chaque partie utilise des différentes broches afin de pouvoir utiliser seulement une carte Arduino.

==Fonction Pixy2 + Boussole + Se déplacer==

Pour se faire, comme vous l'avez vu précédemment, le programme de la Pixy renvoyait des données telles que "Tourner à gauche", il a donc suffit de mettre les commandes correspondantes aux moments donnés afin de faire un programme homogène.
Ici, la boussole est liée dans le programme mais n'est pas utilisée, nous l'avons préparée afin de l'utiliser par la suite.
{{boîte déroulante/début|titre=Code_Mise en commun se déplacer + Pixy2}}
<source lang=c>
#include "MPU9250.h"

int boussole;
int N = 50;
int K = 0.3;

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;
Module_magnetic = sqrt(Module_magnetic);

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

return angle;
}

#include <Pixy2.h>

// This is the main Pixy object
Pixy2 pixy;

int E1 = 5;
int M1 = 4;
int E2 = 6;
int M2 = 7;

void setup()
{
Serial.begin(115200);
Serial.print("Starting...\n");

pixy.init();

pinMode(M1, OUTPUT);
pinMode(M2, OUTPUT);

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

// start communication with 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) {}
}

IMU.setAccelRange(MPU9250::ACCEL_RANGE_8G);

IMU.setGyroRange(MPU9250::GYRO_RANGE_500DPS);

IMU.setDlpfBandwidth(MPU9250:: DLPF_BANDWIDTH_20HZ);

IMU.setSrd(19);
}

void loop()
{
int i;
int x;
int y;
// grab blocks!
pixy.ccc.getBlocks();

// si on détecte la balle
if (pixy.ccc.numBlocks)
{

Serial.print("position x de la balle ");
Serial.print(i);
Serial.print(": ");
Serial.println(pixy.ccc.blocks[i].m_x); // on indique la position de la balle sur l'axe x (entre 316 et 0)

if (pixy.ccc.blocks[i].m_x < 103) { // si la balle est plus à gauche par rapport au milieu de l'axe, on tourne à gauche
Serial.println("tourner à gauche");
analogWrite(E1, 50);
analogWrite(E2, (N + K * (158 - pixy.ccc.blocks[i].m_x)));
}

if (pixy.ccc.blocks[i].m_x > 206) {
Serial.println("tourner à droite"); // si la balle est plus à droite par rapport au milieu de l'axe, on tourne à droite
analogWrite(E1, (N + K * (pixy.ccc.blocks[i].m_x - 158)));
analogWrite(E2, 50);
}

Serial.print("position y de la balle ");
Serial.print(i);
Serial.print(": ");
Serial.println(pixy.ccc.blocks[i].m_y);

if (pixy.ccc.blocks[i].m_y > 105 && pixy.ccc.blocks[i].m_x < 206 && pixy.ccc.blocks[i].m_x > 103) { // si la balle est proche
Serial.println("avancer doucement");
analogWrite(E1, 50);
analogWrite(E2, 50);
}

if (pixy.ccc.blocks[i].m_y < 105 && pixy.ccc.blocks[i].m_x < 206 && pixy.ccc.blocks[i].m_x > 103) {
Serial.println("avancer rapidement"); // si la balle est loin
analogWrite(E1, 100);
analogWrite(E2, 100);
}

}

//si on ne détecte pas la balle
else {
Serial.println("chercher la balle");
analogWrite(E1, 50);
analogWrite(E2, 30);
}
delay(1000);

Serial.print(" ");
Serial.print("Angle "); //en degres
Serial.println(angle());
boussole = angle;

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

moyenneFinal = moyenne/100;
Serial.print("Moyenne : ");
Serial.println(moyenneFinal);

delay(1000);

}

</source>
{{boîte déroulante/fin}}

==Mise en commun totale==

Afin de mettre en commun toutes les fonctions, nous n'avons eu qu'à placer chaque fonctions au bon endroit en suivant l'algorithme de développement ( voir PJ première partie ), tout en plaçant chaque ligne de code au bon endroit.
Seul le TIMER des 90 secondes englobera toutes les fonctions afin que celles-ci ne se déroulent seulement si on est en dessous des 90 secondes. Dès lors où nous aurons passé ce temps (85 secondes pour avoir une marge de manoeuvre ), toutes les fonctions seront bloquées et le robot se mettra en route vers la ligne blanche, arrêtera ses moteurs, et mettre en fonctionnement la fonction du Crève-ballon expliquée ci-dessus. La partie sera alors terminée et notre robot validera les points qu'il aura marqué auparavant.

{{boîte déroulante/début|titre=Code_Mise en commun se déplacer + Pixy2}}
<source lang=c>
#include "MPU9250.h" //intégration bibliothèque gyroscope
#include <Pixy2.h> //intégration bibliothèque pixy
#include <Servo.h> //intégration bibliothèque servomoteur

int boussole;

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

static unsigned long debutdutemps = millis();
unsigned long temps_ref;
#define PERIODE 10000

// initialisations du HC SR04 qui détecte la balle pour l'attraper

int trig = 2;
int echo = 3;
long lecture_echo;
long cm;
int balle;
double moyenne;
double moyenneFinal;
int i;

// initialisations du gyroscope

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;
Module_magnetic = sqrt(Module_magnetic);

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

return angle;
}

//initialisations camera pixy
Pixy2 pixy;

int E1 = 5; // moteur gauche
int M1 = 4;
int E2 = 6; // moteur droite
int M2 = 7;
int etat;
int N = 100;
int K = 0.3;
int NORD;

const int BpNord = 10; // variable qui gère l'initialisation du bouton qui désignera le nord en broche 10

int capteur0;
int capteur1;
int capteur2;

Servo monServomoteurTaper;
Servo monServomoteurBallon;
Servo monServomoteurAttraper;

void setup()
{

monServomoteurAttraper.attach(6); //déclaration servo moteur qui attrape la balle en position zéro
monServomoteurAttraper.write(0);

monServomoteurBallon.attach(8); //déclaration servo moteur qui crève le ballon sur la broche 8 de l’arduino
monServomoteurBallon.write(0); //Mise en position initiale, position 0°

monServomoteurTaper.attach(7); //déclaration servo moteur qui tape la balle en position zéro
monServomoteurTaper.write(0);

temps_ref = millis();

pinMode(BpNord, INPUT); //déclaration bouton qui désignera le nord
//digitalWrite(Bp, HIGH);
pinMode(A0, INPUT); //déclaration d'un détecteur de ligne
pinMode(A1, INPUT); //déclaration d'un détecteur de ligne
pinMode(A2, INPUT); //déclaration d'un détecteur de ligne

Serial.begin(115200);
Serial.print("Starting...\n");

pixy.init();

pinMode(M1, OUTPUT); //déclaration moteur qui oriente le robot
pinMode(M2, OUTPUT); //déclaration moteur qui oriente le robot

pinMode(trig, OUTPUT); //déclaration des broches utilisés pour le hc sr 04
digitalWrite(trig, LOW); //déclaration des broches utilisés pour le hc sr 04
pinMode(echo, INPUT); //déclaration des broches utilisés pour le hc sr 04

Serial.begin(115200);

//boucle qui gère les déclarations du gyroscope
while (!Serial) {}

// début de communication avec le IMU du gyroscope
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) {}
}

IMU.setAccelRange(MPU9250::ACCEL_RANGE_8G);

IMU.setGyroRange(MPU9250::GYRO_RANGE_500DPS);

IMU.setDlpfBandwidth(MPU9250:: DLPF_BANDWIDTH_20HZ);

IMU.setSrd(19);
}

void loop()
{
Serial.print(" ");
Serial.print("Angle "); //en degres
Serial.println(angle());
boussole = angle;

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

}

moyenneFinal = moyenne / 100;
Serial.print("Moyenne : ");
Serial.println(moyenneFinal);

delay(1000);

etat = digitalRead(BpNord);
if (etat == HIGH) {
NORD = angle;
}

//association des 3 capteurs de lignes à 3 variables

int capteur0;
int capteur1;
int capteur2;
int sensorValue0 = analogRead(A0);
int sensorValue1 = analogRead(A1);
int sensorValue2 = analogRead(A2);

// fonction millis qui ordonne au robot au bout d'une certaine période d'aller à la ligne blanche puis de crever le ballon

if ( (millis() - temps_ref) >= PERIODE ) // fonction millis
{
if (angle == 0) // quand le robot est orienté vers le terrain adverse
{
analogWrite(E1, 100); //il avance tout droit
analogWrite(E2, 100);

}
else(boussole = ! NORD); //s'il n'est pas orienté vers le terrain adverse
{
analogWrite(E1, 50); // il tourne en rond
analogWrite(E2, 30);

}
if ((sensorValue0 > 450) && (sensorValue1 > 30) && (sensorValue2 >450 )&&(sensorValue3 > 200) && (sensorValue4 > 200) && (sensorValue5 >200 ) && (millis() - temps_ref) >= PERIODE) // si tout les capteurs détecte du blanc il s'arrete et crève le ballon
{
Serial.println("ARRET MOTEUR"); //permet de vérifier sur le moniteur série que l'arduino comprend qu'il doit dire au robot de s'arrêter
analogWrite(E1, 0); //moteur à l'arrêt
analogWrite(E2, 0); //moteur à l'arrêt

// partie crève ballon qui fais faire varier l'angle du servomoteur en boucle
monServomoteurBallon.write(90);
delay(1000);

monServomoteurBallon.write(0);
delay(0000);

}

temps_ref = millis();
}

else { //si la fonction millis ne c'est pas encore arrêté

if ((sensorValue0 > 450) && (sensorValue1 > 30) && (sensorValue2 > 450 )) //le robot détecte la grosse ligne blanche du milieu
{
Serial.println("ARRET MOTEUR");
analogWrite(E1, 0); //arrêt des moteurs
analogWrite(E2, 0); //arrêt des moteurs
delay(2000); //pause de 2secondes
analogWrite(E1, 80); //le moteur fais demi-tour
analogWrite(E2, 50); //le moteur fais demi-tour
delay(3000); //pause de 3 secondes
}

// partie qui associe la caméra pixy aux moteurs
int i;
int x;
int y;
// grab blocks!
pixy.ccc.getBlocks();

// si on détecte la balle
if (pixy.ccc.numBlocks)
{

Serial.print("position x de la balle ");
Serial.print(i);
Serial.print(": ");
Serial.println(pixy.ccc.blocks[i].m_x); // on indique la position de la balle sur l'axe x (entre 316 et 0)

if (pixy.ccc.blocks[i].m_x < 158) { // si la balle est plus à gauche par rapport au milieu de l'axe, on tourne à gauche
Serial.println("tourner à gauche");
analogWrite(E2, (N + K * (158 - pixy.ccc.blocks[i].m_x)));
analogWrite(E1, N);
}

if (pixy.ccc.blocks[i].m_x > 158) {
Serial.println("tourner à droite"); // si la balle est plus à droite par rapport au milieu de l'axe, on tourne à droite
analogWrite(E2, N);
analogWrite(E1, (N + K * (pixy.ccc.blocks[i].m_x - 158)));
}

Serial.print("position y de la balle ");
Serial.print(i);
Serial.print(": ");
Serial.println(pixy.ccc.blocks[i].m_y);

if (pixy.ccc.blocks[i].m_y > 105 && pixy.ccc.blocks[i].m_x == 158 ) { // si la balle est au centre de l'axe, on avance à la même vitesse
Serial.println("avancer doucement");
analogWrite(E1, 90);
analogWrite(E2, 90);
}

if (pixy.ccc.blocks[i].m_y < 105 && pixy.ccc.blocks[i].m_x == 158) {
Serial.println("avancer rapidement"); // si la balle est plus à droite par rapport au milieu de l'axe, on tourne à droite
analogWrite(E1, 120);
analogWrite(E2, 120);
}

}

//si on ne détecte pas la balle
else {
Serial.println("chercher la balle");
analogWrite(E1, 80);
analogWrite(E2, -80);
}

//partie qui calcul la distance en boule à l'aide du hc sr 04

digitalWrite(trig, HIGH);
delayMicroseconds(10);
digitalWrite(trig, LOW);
lecture_echo = pulseIn(echo, HIGH);
cm = lecture_echo / 58;
Serial.print("Distance en cm :");
Serial.println(cm);
delay(500);

if (cm < 13) // si le hc sr 04 capte une balle/présence un servo moteur attrape la balle
{

Serial.print("Balle attrapée");
monServomoteurAttraper.write(90);
delay(100);
balle = 1;

}
if (cm > 14) { // si le hc sr 04 ne capte rien, le servo moteur reste en position ouverte
Serial.print("Balle va être attrapée");
monServomoteurAttraper.write(0);
delay(100);
balle = 0;
}

// partie qui associe le gyroscope aux servomoteur qui attrape, et qui tape la balle une fois sur la ligne blanche du milieu

if (balle = 1) {
if (angle < NORD + 5) && (angle > NORD - 5) { // si nous sommes dirigé vers le nord
digitalWrite(E1, N);
digitalWrite(E2, N);
}
while ( angle =! NORD) {
digitalWrite(E1, N);
digitalWrite(E2, 65);
delay(1000);
}
}

if ((sensorValue0 > 500) && (sensorValue1 > 400) && (sensorValue2 > 200)) // ligne blanche le servomoteur relache la balle et l'autre servomoteur tape la balle
{
Serial.println("ARRET MOTEUR");
analogWrite(E1, 0); //arrêt des moteurs
analogWrite(E2, 0); //arrêt des moteurs
monServomoteurAttraper.write(90);
delay(2000);
monServomoteurTaper.write(90);
}
else if ((sensorValue0 < 450) && (sensorValue1 < 400) && (sensorValue2 < 200)) //le robot n'est plus sur la ligne blanche donc il fait demi tour en remettant le servomoteur qui tape la bale en position 0
{
monServomoteurTaper.write(0);
analogWrite(E1, 80); //le moteur fais demi-tour
analogWrite(E2, 50); //le moteur fais demi-tour
}
}
</source>
{{boîte déroulante/fin}}

Robotique2 2

2021-03-16T09:19:13Z

Robotique2 2 :

Robotique2 2

2021-03-16T08:29:14Z

Robotique2 2 :

Fichier:VisuelPixy2.jpg

2021-03-09T09:52:44Z

Robotique2 2 :

Vision de la caméra grâce à PixyMon

Fichier:Pixy2.jpg

2021-03-09T09:52:05Z

Robotique2 2 :

Caméra Pixy2 sur le socle du robot.

RobotiqueCoupeGEII2

2021-03-09T09:25:32Z

Robotique2 2 :

Fichier:Capture d’écran 2021-03-09 10-21-10.png

2021-03-09T09:23:40Z

Robotique2 2 :

Algorithme du fonctionnement

RobotiqueCoupeGEII2

2021-03-09T09:01:41Z

Robotique2 2 :

[[Catégorie:Projets]]

=Présentation du projet=

Un fil pilote est un conducteur utilisé pour transmettre des commandes à des appareils raccordés sur le secteur. 

Les commandes envoyées sur le fil pilote permettent de définir le mode de fonctionnement des appareils qui les reçoivent. 

L'avantage du fil pilote est que l'information n'est transmise que sur un seul fil, le retour étant assuré par le conducteur "Neutre" qui est aussi utilisé pour alimenter l'appareil. 

Le signal envoyé sur le fil pilote est généré par un appareil spécifique. Les signaux de commande ont la particularité d'être "fabriqués" directement à partir de la tension 230V du réseau. 

[[Fichier:Fil-pilote.gif|500px||signaux de commande]]
[[Fichier:Fil pilote principe.jpg|500px||principe d'une commande par fil pilote]]

Par exemple, les radiateurs électriques raccordés à un même fil pilote, pourront basculer simultanément du mode "Hors gel" au mode "Eco".

=={{Bleu|Objectif}}==

Le projet consiste à fabriquer une carte électronique capable de décoder les signaux de commande et d'afficher le signal transmis à l'aide d'une led.

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

[[Fichier:Decodeur fil pilote fonctions.jpg|800px||découpage fonctionnel]]

=={{Bleu|Contraintes de fabrication}}==

La carte utilisera un microcontrôleur ATtiny2313. 

Le signal issu du fil pilote sera isolé par un optocoupleur. 

Les six modes de fonctionnement seront matérialisés par six LED. 

={{Rouge|Travail attendu}}=

{| class="wikitable"
|-
! A !! Ze !! E
|-
| Ta || Tzle || Texte de la cellule
|-
| Texte de la cellule || Texte de la cellule || Texte de la cellule
|-
| Texte de la cellule || Texte de la cellule || Texte de la cellule
|}