Aller au contenu


Mickixe

Inscrit(e) (le) 02 nov. 2019
Déconnecté Dernière activité févr. 02 2020 12:49
-----

Messages que j'ai postés

Dans le sujet : Mon projet perso de robot mobile - présentation et demande d'avis

02 février 2020 - 12:49

Ok, merci pour tes conseils, je comprends le principe, je vais travailler cela, dès que je pourrai... mon PC "Hobby" a eu la bonne idée de rendre l'âme ce soir, et donc perte d'une bonne partie de mes données (et pas ou difficilement récupérable, disque emmc soudé...), heureusement que j'ai posté ici mes codes entiers sur mon projet en cours !!!


Dans le sujet : Mon projet perso de robot mobile - présentation et demande d'avis

01 février 2020 - 09:39

Ok, on va commencer par la carte capteurs.

J'ai allégé le programme pour ne commencer qu'avec 1 seul capteur, car j'avais déjà un soucis que j'avais alors résolut avec un delay.

Voilà le code allégé et pour cette carte seule, cela marche.

if(sonar1.ping_cm() < distance_Prudent && sonar1.ping_cm() > distance_Arret) { 
    Serial.print('p'); }//prudent avant
  else if(sonar1.ping_cm() < distance_Arret) { 
    Serial.print('i'); }//1/2 tour
  else { Serial.print('o'); }  

Le moniteur série m'affiche bien une série continue de oooooo...pppp...iiii,  en fonction de la distance.


Dans le sujet : Mon projet perso de robot mobile - présentation et demande d'avis

01 février 2020 - 08:35

Merci pour ta réponse.

Oui, pour le delay j'en ai fait l'expérience... J'avais essayé avec millis(), mais sans succès, mais sans doute mal utilisé aussi...

 

Voici les parties de codes bloquantes selon moi :

Je pense que je n'ai pas la bonne méthode : suivant la plage de distance détectée sur la carte capteurs, j'associe une lettre que j'envoie sur lacarte actionneurs. Celle-ci est lue et donne une action. Mais comme cet envoi est en continue, cela ne permet pas aux fonctions de s'exécuter correctement.

 

Te remerciant par avance,

Mickaël

 

Carte capteurs :

//Cas prudent
  if(sonar1.ping_cm() < distance_Prudent && sonar1.ping_cm() > distance_Arret && sonar2.ping_cm() > distance_Arret && sonar3.ping_cm() > distance_Arret) { 
    Serial.print('p'); }//prudent avant
  else if(sonar1.ping_cm() < distance_Prudent && sonar1.ping_cm() > distance_Arret && sonar2.ping_cm() <= distance_Arret && sonar3.ping_cm() > distance_Arret) { 
    Serial.print('r');delay(1000); }//prudent avant tourne droite
  else if(sonar1.ping_cm() < distance_Prudent && sonar1.ping_cm() > distance_Arret && sonar2.ping_cm() > distance_Arret && sonar3.ping_cm() <= distance_Arret) { 
    Serial.print('l');delay(1000); }//prudent avant tourne gauche
  else if(sonar1.ping_cm() < distance_Prudent && sonar1.ping_cm() > distance_Arret && sonar2.ping_cm() <= distance_Arret && sonar3.ping_cm() <= distance_Arret) { 
    Serial.print('i');delay(1000); }//1/2 tour
  //Cas recule
  else if(sonar1.ping_cm() < distance_Arret && sonar2.ping_cm() > distance_Arret && sonar3.ping_cm() > distance_Arret) { 
    Serial.print('i');delay(1000); }//1/2 tour
  else if(sonar1.ping_cm() < distance_Arret && sonar2.ping_cm() <= distance_Arret && sonar3.ping_cm() > distance_Arret) { 
    Serial.print('g');delay(1000); }//recule tourne gauche
  else if(sonar1.ping_cm() < distance_Arret && sonar2.ping_cm() > distance_Arret && sonar3.ping_cm() <= distance_Arret) { 
    Serial.print('d');delay(1000); }//prudent avant tourne droite
  else if(sonar1.ping_cm() < distance_Arret && sonar2.ping_cm() <= distance_Arret && sonar3.ping_cm() <= distance_Arret) { 
    Serial.print('i');delay(1000); }//1/2 tour
  else { Serial.print('o'); }

Carte actionneurs :

if (Serial.available() > 0) {
    distance = Serial.read();
    if (distance=='o') {//avance
      Eyes(0);
      digitalWrite(A0,LOW);
      digitalWrite(A1,HIGH);
      digitalWrite(A2,LOW);
      avance(200);
    }
    if (distance=='p'){//prudent avant
      Eyes(0);
      digitalWrite(A1,LOW);
      digitalWrite(A2,HIGH);
      digitalWrite(A0,LOW);
      avance(100);
      }    
    if (distance=='r'){//prudent avant tourne droite
      Eyes(-2);
      digitalWrite(A2,HIGH);
      digitalWrite(A0,LOW);
      digitalWrite(A1,LOW);
      prudentdroite(100);
      } 
    if (distance=='l'){//prudent avant tourne gauche
      Eyes(2);
      digitalWrite(A2,HIGH);
      digitalWrite(A0,LOW);
      digitalWrite(A1,LOW);
      prudentgauche(100);
      } 
    if (distance=='i') {//demi-tour
      Eyes(0);
      digitalWrite(A0,LOW);
      digitalWrite(A1,HIGH);
      digitalWrite(A2,LOW);
      demitour(100);
    }
     if (distance=='g') {//recule tourne gauche
      Eyes(-2);
      digitalWrite(A0,LOW);
      digitalWrite(A1,HIGH);
      digitalWrite(A2,LOW);
      reculegauche(100);
     }
    if (distance=='d') {//recule tourne droite
      Eyes(2);
      digitalWrite(A0,LOW);
      digitalWrite(A1,HIGH);
      digitalWrite(A2,LOW);
      reculedroite(100);
    }
   }

Dans le sujet : Mon projet perso de robot mobile - présentation et demande d'avis

01 février 2020 - 06:35

Bonjour,

 

Bon, mon projet végète un peu, je n'arrive pas à bien gérer les échanges entre les 2 cartes, je pense que mon code est foireux, où je ne sais pas bien quelle(s) information(s) envoyer et sous quelle forme... Disons qu'avec un capteur, j'arrive à faire fonctionner, avec plusieurs, ça ne marche plus...

Ci-dessous, mes codes, n'hésitez pas à me faire part de vos remarques/critiques/pistes d'amélioration...

(NB : j'ai intégré du delay dans le code capteur pour laisser ensuite le temps aux fonctions de s'éxecuter. Quand j'intégrais du delay dans ma condition Serial.available(), j'ai l'impression que cela venait stopper la communication...)

 

Vous remerciant par avance pour votre aide,

Mickaël

 

Carte capteurs US (x3) : 

#include <NewPing.h>

//Sonar1 avant
#define TRIGGER_PIN1  9
#define ECHO_PIN1     8

//Sonar2 gauche
#define TRIGGER_PIN2  5 
#define ECHO_PIN2     4

//Sonar3 droite
#define TRIGGER_PIN3  6  
#define ECHO_PIN3     7  

#define distance_Arret 20
#define distance_Prudent 50
#define MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

NewPing sonar1(TRIGGER_PIN1, ECHO_PIN1, MAX_DISTANCE);
NewPing sonar2(TRIGGER_PIN2, ECHO_PIN2, MAX_DISTANCE);
NewPing sonar3(TRIGGER_PIN3, ECHO_PIN3, MAX_DISTANCE);


void setup() {
  Serial.begin(115200); 
}

void loop() {
  delay(50);                     // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings.

//  **** Commandes pour test fonctionnement ****
//  Serial.print("Ping1: ");
//  Serial.print(sonar1.ping_cm()); // Send ping, get distance in cm and print result (0 = outside set distance range)
//  Serial.println("cm");
//  delay(1000); 
//  Serial.print("Ping2: ");
//  Serial.print(sonar2.ping_cm()); // Send ping, get distance in cm and print result (0 = outside set distance range)
//  Serial.println("cm");
//  delay(1000); 
//  Serial.print("Ping3: ");
//  Serial.print(sonar3.ping_cm()); // Send ping, get distance in cm and print result (0 = outside set distance range)
//  Serial.println("cm");
//  delay(1000); 

  //Cas prudent
  if(sonar1.ping_cm() < distance_Prudent && sonar1.ping_cm() > distance_Arret && sonar2.ping_cm() > distance_Arret && sonar3.ping_cm() > distance_Arret) { 
    Serial.print('p'); }//prudent avant
  else if(sonar1.ping_cm() < distance_Prudent && sonar1.ping_cm() > distance_Arret && sonar2.ping_cm() <= distance_Arret && sonar3.ping_cm() > distance_Arret) { 
    Serial.print('r');delay(1000); }//prudent avant tourne droite
  else if(sonar1.ping_cm() < distance_Prudent && sonar1.ping_cm() > distance_Arret && sonar2.ping_cm() > distance_Arret && sonar3.ping_cm() <= distance_Arret) { 
    Serial.print('l');delay(1000); }//prudent avant tourne gauche
  else if(sonar1.ping_cm() < distance_Prudent && sonar1.ping_cm() > distance_Arret && sonar2.ping_cm() <= distance_Arret && sonar3.ping_cm() <= distance_Arret) { 
    Serial.print('i');delay(1000); }//1/2 tour
  //Cas recule
  else if(sonar1.ping_cm() < distance_Arret && sonar2.ping_cm() > distance_Arret && sonar3.ping_cm() > distance_Arret) { 
    Serial.print('i');delay(1000); }//1/2 tour
  else if(sonar1.ping_cm() < distance_Arret && sonar2.ping_cm() <= distance_Arret && sonar3.ping_cm() > distance_Arret) { 
    Serial.print('g');delay(1000); }//recule tourne gauche
  else if(sonar1.ping_cm() < distance_Arret && sonar2.ping_cm() > distance_Arret && sonar3.ping_cm() <= distance_Arret) { 
    Serial.print('d');delay(1000); }//prudent avant tourne droite
  else if(sonar1.ping_cm() < distance_Arret && sonar2.ping_cm() <= distance_Arret && sonar3.ping_cm() <= distance_Arret) { 
    Serial.print('i');delay(1000); }//1/2 tour
  else { Serial.print('o'); }
  
}

Carte Actionneurs :

//Moteurs
#include <Wire.h> //bibliothèque pour la communication I2C
#include <Adafruit_MotorShield.h> //bibliothèque pour le shield
Adafruit_MotorShield monShield = Adafruit_MotorShield(); //création de l'objet shield
Adafruit_DCMotor *moteurArGauche = monShield.getMotor(1); //création de l'objet moteurArrièreGauche par pointeur et repérage du numéro
Adafruit_DCMotor *moteurArDroite = monShield.getMotor(2); //création de l'objet moteurArrièreDroite par pointeur et repérage du numéro
Adafruit_DCMotor *moteurAvGauche = monShield.getMotor(4); //création de l'objet moteurAvantGauche par pointeur et repérage du numéro
Adafruit_DCMotor *moteurAvDroite = monShield.getMotor(3); //création de l'objet moteurAvantDroite par pointeur et repérage du numéro

//Infra-Rouge
#include <IRremote.h>
long val;
int IRpin =A3;
IRrecv irrecv(IRpin);
decode_results results;

//Servos
//#include <Adafruit_PWMServoDriver.h>////bibliothèque pour la carte servo
//Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
//#define SERVOMIN  150 // this is the 'minimum' pulse length count (out of 4096)
//#define SERVOMAX  550 // this is the 'maximum' pulse length count (out of 4096)
//uint16_t pulselen0=SERVOMIN;
//uint16_t pulselen1=SERVOMIN;
//uint16_t pulselen2=SERVOMIN;
//uint16_t pulselen3=SERVOMIN;
//uint8_t servo0 = 0;
//uint8_t servo1 = 1;
//uint8_t servo2 = 2;
//uint8_t servo3 = 3;

// LES YEUX DU ROBOT 
#include<LiquidCrystal.h>
#define RS 2
#define E 4
#define D4 5
#define D5 6
#define D6 7
#define D7 8
#define COLS 16
#define ROWS 2
LiquidCrystal lcd(RS,E,D4,D5,D6,D7);
byte eye1[8]=
{
B00000,
B00001,
B00010,
B00100,
B00100,
B01000,
B01000,
B01000,
};
byte eye3[8]=
{
B11111,
B00000,
B00000,
B00000,
B00000,
B00000,
B10001,
B01110,
};
byte eye5[8]=
{
B00000,
B10000,
B01000,
B00100,
B00100,
B00010,
B00010,
B00010,
};
byte eye2[8]=
{
B01000,
B01000,
B01000,
B00100,
B00100,
B00010,
B00001,
B00000,
};
byte eye4[8]=
{
B01110,
B00000,
B00000,
B00000,
B00000,
B00000,
B00000,
B11111,
};
byte eye6[8]=
{
B00010,
B00010,
B00010,
B00100,
B00100,
B01000,
B10010,
B00000,
};

//Capteurs US
int distance;
unsigned long time = millis();

//SD et sons
#include <SD.h>
#include <TMRpcm.h>
//Constants
#define SD_ChipSelectPin 10
const int speakerPin=9;
//Objects
TMRpcm tmrpcm;  


void setup() {
  //MOTEURS
  monShield.begin(); //On lance la communication avec le shield
  
  //IR
  Serial.begin(115200);
  irrecv.enableIRIn();

  //Servos
  //pwm.begin();
  //pwm.setPWMFreq(60);  // Analog servos run at ~60 Hz updates
  //delay(10);

  //Yeux
  lcd.begin(COLS,ROWS);
  lcd.createChar(0,eye1);
  lcd.createChar(1,eye2);
  lcd.createChar(2,eye3);
  lcd.createChar(3,eye4);
  lcd.createChar(4,eye5);
  lcd.createChar(5,eye6);
  Eyes(0);

  //LED
  pinMode(A0,OUTPUT);//Rouge
  pinMode(A1,OUTPUT);//Verte
  pinMode(A2,OUTPUT); //Jaune
  digitalWrite(A0,HIGH);
  digitalWrite(A1,HIGH);
  digitalWrite(A2,HIGH);
  delay(1000);
  digitalWrite(A0,LOW);
  digitalWrite(A1,HIGH);
  digitalWrite(A2,LOW);

  //SD et Sons
  //Init sd shield
  if (!SD.begin(SD_ChipSelectPin)) {Serial.println("SD fail"); return; }
  //Init speaker
  tmrpcm.speakerPin = speakerPin;
  tmrpcm.setVolume(7);
  tmrpcm.play("p0.wav");

}


//*******************
//*****MAIN**********
//*******************

void loop() {

  
  //LED
 
  if (Serial.available() > 0) {
    distance = Serial.read();
    if (distance=='o') {//avance
      Eyes(0);
      digitalWrite(A0,LOW);
      digitalWrite(A1,HIGH);
      digitalWrite(A2,LOW);
      avance(200);
    }
    if (distance=='p'){//prudent avant
      Eyes(0);
      digitalWrite(A1,LOW);
      digitalWrite(A2,HIGH);
      digitalWrite(A0,LOW);
      avance(100);
      }    
    if (distance=='r'){//prudent avant tourne droite
      Eyes(-2);
      digitalWrite(A2,HIGH);
      digitalWrite(A0,LOW);
      digitalWrite(A1,LOW);
      prudentdroite(100);
      } 
    if (distance=='l'){//prudent avant tourne gauche
      Eyes(2);
      digitalWrite(A2,HIGH);
      digitalWrite(A0,LOW);
      digitalWrite(A1,LOW);
      prudentgauche(100);
      } 
    if (distance=='i') {//demi-tour
      Eyes(0);
      digitalWrite(A0,LOW);
      digitalWrite(A1,HIGH);
      digitalWrite(A2,LOW);
      demitour(100);
    }
     if (distance=='g') {//recule tourne gauche
      Eyes(-2);
      digitalWrite(A0,LOW);
      digitalWrite(A1,HIGH);
      digitalWrite(A2,LOW);
      reculegauche(100);
     }
    if (distance=='d') {//recule tourne droite
      Eyes(2);
      digitalWrite(A0,LOW);
      digitalWrite(A1,HIGH);
      digitalWrite(A2,LOW);
      reculedroite(100);
    }
   }
  
  //IR
  if (irrecv.decode(&results)==1){
    val=results.value;
    Serial.println(val);
    irrecv.resume(); 
  }
  switch (val){
    case 16718055://Avance - touche 2
     Eyes(0);
      tmrpcm.play("p0.wav");
      delay(1000);
      avance(255);
      delay(1000);
      arret();
      break;
    case 16730805://Recule - touche 8
      Eyes(0);
      recule(255);
      delay(1000);
      arret();
      break;
   case 16716015://Va à gauche - touche 4
      Eyes(2);
      tmrpcm.play("p2.wav");
      lateralGauche(255);
      delay(1000);
      arret();
      break;
    case 16734885://Va à droite - touche 6
      Eyes(-2);
      lateralDroite(255);
      delay(1000);
      arret();
      break;
//    case 16724175://Servo 2 - touche 1
//      pulselen1=pulselen1+10;
//      Serial.println(pulselen1);
//      pwm.setPWM(servo1, 0, pulselen1);// commande du servo.
//      if (pulselen1>SERVOMAX){pulselen1=SERVOMIN;}
//      break;
//    case 16743045://Servo 3 - touche 3
//      pulselen2=pulselen2+10;
//      Serial.println(pulselen2);
//      pwm.setPWM(servo2, 0, pulselen2);// commande du servo.
//      if (pulselen2>SERVOMAX){pulselen2=SERVOMIN;}
//      break;
//    case 16728765://Servo 1 - touche 7
//      pulselen0=pulselen0+10;
//      Serial.println(pulselen0);
//      pwm.setPWM(servo0, 0, pulselen0);// commande du servo.
//      if (pulselen0>SERVOMAX){pulselen0=SERVOMIN;}
//      break;
//    case 16732845://Servo 4 - touche 9
//      pulselen3=pulselen3+10;
//      Serial.println(pulselen3);
//      pwm.setPWM(servo3, 0, pulselen3);// commande du servo.
//      if (pulselen3>SERVOMAX){pulselen3=SERVOMIN;}
//      break;
    default :
      
      break;
  }  

 }

  
//*******************
//*****FONCTIONS*****
//*******************

//fonctions de mouvement de la plateforme
void arret(){
  //fonction d'arrêt des deux moteurs
  moteurArGauche->run(RELEASE);
  moteurArDroite->run(RELEASE);
  moteurAvGauche->run(RELEASE);
  moteurAvDroite->run(RELEASE);
}
void defVitesse(int v){
  moteurArGauche->setSpeed(v); //on redéfinit la vitesse
  moteurArDroite->setSpeed(v); //des deux moteurs
  moteurAvGauche->setSpeed(v); //on redéfinit la vitesse
  moteurAvDroite->setSpeed(v); //des deux moteurs
}
void avance(int v){
  //fonction de marche avant
  defVitesse(v); //appel de la fonction pour définir la vitesse
  moteurArGauche->run(FORWARD);
  moteurArDroite->run(FORWARD);
  moteurAvGauche->run(FORWARD);
  moteurAvDroite->run(FORWARD);
}
void prudentdroite(int v){
  //fonction de tourne à droite en mode prudent
  defVitesse(v); //appel de la fonction pour définir la vitesse
  moteurArGauche->run(FORWARD);
  moteurArDroite->run(RELEASE);
  moteurAvGauche->run(FORWARD);
  moteurAvDroite->run(RELEASE);
}
void prudentgauche(int v){
  //fonction de tourne à gauche en mode prudent
  defVitesse(v); //appel de la fonction pour définir la vitesse
  moteurArGauche->run(RELEASE);
  moteurArDroite->run(FORWARD);
  moteurAvGauche->run(RELEASE);
  moteurAvDroite->run(FORWARD);
}
void demitour(int v){
  //fonction de tourne à gauche en mode prudent
  defVitesse(v); //appel de la fonction pour définir la vitesse
  moteurArGauche->run(BACKWARD);
  moteurArDroite->run(FORWARD);
  moteurAvGauche->run(BACKWARD);
  moteurAvDroite->run(FORWARD);
}
void reculedroite(int v){
  //fonction de marche arrière
  defVitesse(v);
  moteurArGauche->run(BACKWARD);
  moteurArDroite->run(RELEASE);
  moteurAvGauche->run(BACKWARD);
  moteurAvDroite->run(RELEASE);  
}
void reculegauche(int v){
  //fonction de marche arrière
  defVitesse(v);
  moteurArGauche->run(RELEASE);
  moteurArDroite->run(BACKWARD);
  moteurAvGauche->run(RELEASE);
  moteurAvDroite->run(BACKWARD);  
}

//AVEC TELECOMMANDE
void recule(int v){
  //fonction de marche arrière
  defVitesse(v);
  moteurArGauche->run(BACKWARD);
  moteurArDroite->run(BACKWARD);
  moteurAvGauche->run(BACKWARD);
  moteurAvDroite->run(BACKWARD);  
}
void lateralDroite(int v){
  //fonction pour tourner à droite sur place
  defVitesse(v);
  moteurArGauche->run(BACKWARD);
  moteurArDroite->run(FORWARD);
  moteurAvGauche->run(FORWARD);
  moteurAvDroite->run(BACKWARD);
}
void lateralGauche(int v){
  //fonction pour tourner à droite sur place
  defVitesse(v);
  moteurArGauche->run(FORWARD);
  moteurArDroite->run(BACKWARD);
  moteurAvGauche->run(BACKWARD);
  moteurAvDroite->run(FORWARD);
}
void Droite(int v){
  //fonction pour tourner à droite sur place
  defVitesse(v);
  moteurArGauche->run(RELEASE);
  moteurArDroite->run(FORWARD);
  moteurAvGauche->run(FORWARD);
  moteurAvDroite->run(RELEASE);
}
void Gauche(int v){
  //fonction pour tourner à droite sur place
  defVitesse(v);
  moteurArGauche->run(FORWARD);
  moteurArDroite->run(RELEASE);
  moteurAvGauche->run(RELEASE);
  moteurAvDroite->run(FORWARD);
}

//Fonction mouvement des yeux
void Eyes(int pos){
lcd.clear();
int b=4+pos;
for(int i=0;i<2;i++){
int a=5*i;
lcd.setCursor(0+b+a,0);
lcd.write(byte(0));
lcd.setCursor(1+b+a,0);
lcd.write(byte(2));
lcd.setCursor(2+b+a,0);
lcd.write(byte(4));
lcd.setCursor(0+b+a,1);
lcd.write(byte(1));
lcd.setCursor(1+b+a,1);
lcd.write(byte(3));
lcd.setCursor(2+b+a,1);
lcd.write(byte(5));
}
delay(500);
}

Dans le sujet : Mon projet perso de robot mobile - présentation et demande d'avis

19 janvier 2020 - 03:32

Bonjour,

 

Merci pour vos commentaires !

 

Après 1/2 journée à me prendre la tête sur la liaison série de mes cartes et le code correspondant (j'ai également essayé de passer en i2c) : sans succès...

 

Après vos commentaires (Sandro, les 2 tests avec la fonction avance(255) dans la loop et la setup ont bien fonctionné), j'ai cherché ailleurs et j'ai redécomposé mon code et ai trouvé le problème : il y avait conflit avec la partie de code pour la gestion de la télécommande IR : dans mon switch/case, j'avais indiqué une commande par défaut, à savoir la fonction arret() des moteurs... En retirant simplement cette ligne, ça marche impecc !!!

 

Voilà, problème résolu, je vais pouvoir continuer. Je posterai à l'occasion les évolutions.

 

Merci encore pour votre aide !

Bonne journée

Mickaël