Sommaire

1 Présentation du projet
2 Fonctionnement du robot
3 Mise en commun des différents programmes
- 3.1 Fonction Pixy2 + Boussole + Se déplacer
- 3.2 Mise en commun totale

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

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 :

[Développer]

Code_Pixy2

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 :

Caméra Pixy2
PixyMon

Crève-ballon & pièces 3D

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.

[Développer]

Code_Crève Ballon

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.

[Développer]

Code_Frapper la balle

[Développer]

Code_Attraper la balle

Détecter les lignes & créer un compte à rebours

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.

[Développer]

Code_Détecteur de ligne

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.

[Développer]

Code_SeDéplacer

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.

[Développer]

Code_Mise en commun se déplacer + Pixy2

#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);

}

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.

[Développer]

Code_Mise en commun se déplacer + Pixy2

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

Robotique2 2

Sommaire

Présentation du projet

Fonctionnement du robot

Caméra Pixy2, Boussole & création physique

Crève-ballon & pièces 3D

Fonction frapper la balle & la retenir

Détecter les lignes & créer un compte à rebours

Fonction se déplacer

Mise en commun des différents programmes

Fonction Pixy2 + Boussole + Se déplacer

Mise en commun totale

Menu de navigation

Outils personnels

Espaces de noms

Variantes

Affichages

Plus

Rechercher

Navigation

Outils