Et exit LabView.

Ça confirme la portée plutôt pour des enfants.

Après à voir, il y a certainement du bon.

Mais le fait que les anciens systèmes (capteurs, moteurs) ne seront pas compatibles, ça condamne l'existant et ça c'est vraiment dommage... Le problème des systèmes propriétaires...

Il faudra voir ce que donne ce prochain remplaçant de l'EV3, mais j'avoue que les premiers visuels ne m'engagent pas trop, effectivement plus enfantin et plusieurs fonctionnalités semblent disparaître (l'écran par exemple). Et j'avais cru voir que Lego abandonnerait LabView pour migrer sur une programmation type scratch, à l'image de ce qu'ils ont fait avec Makecode (mais j'arrive plus à retrouver ma source...).

 

Après j'utilise principalement l'EV3 pour faire des prototypes, car plus rapide, ou avec mes enfants.

Je suis ensuite aussi à utiliser une base arduino, mais avec de la construction Lego car, comme le dit Oracid, très puissante pour l'assemblage structure et mécanique. D'autant que j'aime bien faire et défaire. 

 

Ensuite l'arduino n'est pas si compliqué que ça. Il faut effectivement s'y mettre un peu au début (pour ma part, j'avais fait les 2 openClassroom sur le sujet pour assimiler les bases), ensuite, cela devient effectivement beaucoup de copier-coller suivant les composants utilisés. Et puis il y a une communauté et biblio énorme et on arrive généralement toujours à trouver solution sur le net.

 

Sinon, il y a toujours la solution du scratch, pour programmer en blocs. Dans ce cadre, il y a le makeblock qui peut être intéressant, avec une mécanique de type meccano et une panoplie très large de composants (même si un peu cher que ce qu'on peut trouver pour de l'arduino classique). S'orienter dans ce cas sur le kit type mBot Ranger qui comprend la carte Me Auriga qui a plus de ports. Et il très facile de pouvoir imprimer toute sorte de pièces adaptables. Cela peut être une bonne transition entre l'EV3 et le monde de l'arduino.

Bonsoir,

 

Il semble que 2020 soit l'année de fin de commercialisation de l'EV3. Le set Home se retrouve dans les produits bientôt retirés sur le site Lego. Et il est annoncé un nouveau set, réf 51515 Robot Inventor pour cette année (août ?).

Il se rapprocherait des technos utilisés pour le set Spike Prime. A suivre.

 

A+

Mickaël

Bonjour,

 

Merci Oracid pour ton message et cette info, je vais regarder cela.

 

Mickaël

Bonjour,

 

Pour donner quelques suites et avancement de mon projet, après une petite pause où je me suis consacré à mon lego mindstorm qui reposait depuis pas mal de temps dans sa boîte, j'ai repris mon projet que j'ai bien revu, où je suis reparti sur une base lego pour la structure du véhicule, bien plus solide.

 

Les fonctionnalités sont les suivantes (pour l'instant) :

- 2 moteurs CC 12V pour la propulsion,

- 1 servo pour la direction (j'ai abandonné mes roues mecanum, entièrement imprimées, mais qu'il faudrait que je modifie pour améliorer l'adhérence),

- 1 écran Oled pour des yeux (type robot Cozmo),

- 1 lecteur carte SD + Haut-parleur pour mettre un peu de son,

- 1 capteur US pour détection d'obstacle,

- Quelques Led,

- 1 capteur IR pour pilotage avec une télécommande (principalement utilisé pour les tests)

 

Le tout commandé par une arduino mega 2560 et alimenté par une LiPo 12V.

 

J'ai en effet abandonné mon idée de départ de 2 arduino en communication série que je peinais à bien faire fonctionner et surtout pour des raisons de mémoire. Les fonctions pour la SD et l'Oled sont très gourmandes et je suis vite arriver à dépasser la mémoire de la Uno...

De plus j'ai eu à faire face à des conflits de bibliothèques entre le servo, l'US et le son... Il a fallut jongler avec les timers et la mega offrait plus de possibilités.

 

Bref, tout fonctionne bien comme souhaité   et je suis satisfait du résultat obtenu, ce qui me donne une bonne base pour continuer. Je pense faire évoluer le projet pour le rendre plus autonome et je souhaite le doter d'une pince. Je retravaillerai le design également, ça ne ressemble pas à grand chose pour l'instant , mais ce n'était pas le but... Je laisserai de côté pour cette seconde phase le son et les yeux qui restent gadgets.

 

Enfin si vous avez des remarques, des commentaires, des critiques, n'hésitez pas, je suis preneur ! Je reste en phase d'apprentissage !

 

Suite à un prochain épisode !

 

Mickaël

 

 

 

 

 

 

 

 

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 !!!

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.

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

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

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

Bonjour,

 

Merci R1D1 pour l'édit.

 

Merci Sandro pour tes réponses.

Ok pour les batteries.

 

Bien vu pour le code, il y avait effectivement erreur que j'ai corrigée.

 

Par contre, toujours le même soucis, mes moteurs avancent à vitesse réduite... Dans mon programme principal, je gère tous les mouvements de mes moteurs dans la condition 

if (Serial.available() > 0)

Sans doute cela qui pose soucis ?

 

Bon week-end

Mickaël

Bonjour,
 
Comme indiqué dans ma présentation, jusque là j'étais un peu touche à tout, même si je suis resté principalement sur l'arduino.
J'ai toutefois décidé de me lancer dans un projet un peu plus concret et fonctionnel, de manière à mettre en application ce que j'ai pu apprendre jusque là. Objectifs : continuer d'apprendre et s'amuser !
 
Je suis donc parti sur un projet de robot mobile autonome comportant :
- 4 roues mecanum (roues imprimées en 3D (fichiers récupérées sur Thingiverse) et actionnées par des moteurs cc 12V),
- 1 écran LCD matérialisant des yeux qui suivront les mouvements du robot (voire pouvoir changer d'expression),
- 1 haut-parleur émettant des sons enregistrés sur une carte SD,
- de la lumière,
- 1 capteur IR pour avoir la possibilité de le piloter avec une télécommande (et faire ainsi des tests),
- des capteurs US
- un bras muni d'une pince (encore en projet pour l'instant)
 
Pour le châssis, je suis parti pour l'instant sur du carton plume, que je trouve parfait pour une phase de prototypage (perçage à volonté et remplacement facile en cas de casse).
Les pièces de support des composants sont imprimés en 3D (modélisées avec Tinkercad) 
 
Mon montage repose actuellement sur 2 arduino uno :
- 1 avec un shield moteur et qui commande l'écran LCD, les LED, le HP (et donc la lecture de la carte SD) et la réception IR (plus vraiment de pins dispos sur cette carte).
- 1 seconde que je destine pour les capteurs (pour le moment, tests en cours avec des US).
Communication série RX/TX entre les 2 arduino.
 
Voilà le rendu actuel (désolé pour le manque de propreté du câblage, j'améliorerai ce point une fois mon montage figé)
 

 
Au niveau programmation, je suis encore dans une phase de tests, mais ceux-ci s'avèrent globalement concluants, sauf sur 1 point où je bloque actuellement, qui vient, je pense, de ma programmation sur la liaison série entre les 2 cartes. En effet, bien que le capteur US fonctionne et permet de modifier le comportement des moteurs en fonction des distances que j'ai définies, les moteurs fonctionnent à des vitesses extrêmement réduites par rapport à la normale (et que je peux avoir lorsque je commande avec la télécommande IR). Ci-dessous extrait de mes codes pour info.
Comme j'ai projet de mettre plusieurs capteurs US, je voulais sur ce point m'inspirer de la ceinture de capteurs US trouvée sur le forum (super tuto d'ailleurs !), mais dans ce cas, quel code utiliser ? Je n'ai pas essayé de passer en I2C.
 
Je souhaitais également un avis sur les alim :
- J'utilise une batterie LiPo 3S pour l'alim des moteurs,
- Pour les 2 arduino, je les alimente actuellement par une pile 9V chacune. J'ai également une batterie LiPo 2S. Puis-je l'utiliser et elle seule pour alimenter mes cartes ? Cela poserait-il un soucis ? 
 
Voilà, je vous remercie par avance pour l'aide et les conseils que vous pourrez m'apporter.
N'hésitez pas également à apporter tout commentaire/critique ou proposition d'amélioration, je suis encore débutant et tout est bon à prendre pour progresser !
 
Mickaël
 
Extrait code carte "actionneurs" - lecture liaison série
 

Serial.begin(115200);
 
if (Serial.available() > 0) {
    
    distance = Serial.read();
 
   if (distance=='p'){//Mouvement prudent
      digitalWrite(A1,LOW);
      digitalWrite(A2,HIGH);//LED jaune
      digitalWrite(A0,LOW);
      avance(150);//fonction avance à vitesse réduite
      }
    if (distance=='a'){//Arrêt
       digitalWrite(A2,LOW);
       digitalWrite(A0,HIGH);//LED rouge
       digitalWrite(A1,LOW);
       arret();//fonction arrêt
       }
   if (distance=='o'){//Marche
      digitalWrite(A0,LOW);
      digitalWrite(A1,HIGH);//LED verte
      digitalWrite(A2,LOW);
      avance(255);//fonction avance à pleine vitesse
    }

 

Extrait code carte "capteurs" - émission liaison série

Serial.begin(115200);
 
if(sonar1.ping_cm() > distance_Prudent && sonar1.ping_cm() <= distance_Arret) { Serial.print('p'); }
  else if(sonar1.ping_cm() <= distance_Arret) { Serial.print('a'); }
  else { Serial.print('o'); }

Bonsoir,

Merci Sandro pour ta réponse.

Je n'ai pas encore eu l'occasion de tester car la compilation marche et pas de soucis ensuite, mais j'essaierai quand même pour avoir un truc propre !

Mickaël

Bonjour,

 

Je suis actuellement sur un montage basé sur une arduino uno, sur laquelle j'ai un shield moteur, auquel, j'ai connecté également en I2C, un écran LCD et une carte de pilotage de servos (objectif d'en mettre 6). Je commande le tout avec une télécommande IR pour l'instant.

 

Dans mon programme, je fais appel à 2 bibliothèque (Adafruit_MotorShield.h et Adafruit_PWMServoDriver.h)

 

Le montage fonctionne, toutefois lors de la compilation, j'ai un message d'alerte du type :

 

 

 

 

 

Je pense qu'il y a conflit entre les 2 bibliothèques compte tenu que mon shield comporte 2 ports servos.

Bon ça n'est pas bloquant pour le téléversement et ça semble fonctionner, mais c'est pas top quand même...

 

Pouvez-vous me dire svp s'il y a un moyen d'apporter un correctif de manière à ne plus avoir ces messages ?

(modification à apporter dans un des fichier de la bibliothèque ?)

 

Vous remerciant par avance pour votre aide,

 

Mickaël

 

Merci !!!

Super ! Merci pour vos réponses.

 

Ah par contre, du coup, aucun problème pour n'utiliser qu'une alim ?

Jusque là, j'ai toujours séparé l'alim de la carte de celles des actionneurs...

 

Ok pour la pile 9V et RPi, ainsi que pour l'utilisation de la powerbank, merci pour votre confirmation.

 

Autre question, avec une LiPo, si je comprends bien, on y fixe un connecteur mâle XT60 sur lequel on y soude les fils de connexion ?

Pour alimenter une arduino, est-il possible d'y souder une prise jack ?

 

Encore merci pour votre aide, ce forum est une vraie mine d'or !

 

Mickaël 

Bonjour,

 

La question a sans doute été posé mille fois, mais n'ayant pas trouvé réponse complètement, je me permets tout de même de poser mes interrogations, à savoir quel type de batterie est recommandé pour :

 

- Alimenter la carte (arduino, raspberry...) : j'utilise ici en général une pile 9V pour l'arduino, mais est-ce ok pour une RPi (pas sûr... aurais-je l'ampérage suffisant et/ou aurais-je à mettre un convertisseur de tension) ?

J'alimente actuellement ma RPi avec 2 piles Li-ion 3.7 V (avec un convertisseur de tension)

 

- Alimenter les moteurs : j'utilise actuellement des moteurs 6V et j'utilise donc 4 piles 1,5V. Çà marche, mais je préférerai mettre une batterie...

J'ai mes 2 piles Li-ion 3.7 V toujours, mais bon...

De plus, j'envisage d'utiliser des moteurs 12V et là, je me pose sérieusement la question de l'alim.. Que recommandez-vous ?

 

 

J'ai vu que l'usage des batteries lipo semble être un bon compromis, mais je peine à trouver ce qu'il me faudrait...

 

J'ai 2 batteries de modélisme NiMh 7,2V (1800mAh et 3000mAh). Est-ce utilisable ?

 

J'ai une petite powerbank (10400mAh) également que je pensais utiliser, mais je ne suis pas certain que ce soit un choix judicieux... 3A en sortie 5-6V et 1.5A en sortie 9-12V, c'est peut-être un peu fort pour une carte, mais suffisant pour des petits moteurs...

 

Bref, si vous avez quelques conseils à me donner pour m'orienter, je suis preneur !

 

Vous remerciant pour votre aide,

 

Mickaël

Le robot est disponible à l'achat sur le site de DJI (549 € fdp inclus) et même en préco à la Fnac.

Hello,

 

Merci à tous, je vois que la Vendée est force  

Bonjour à tous,

 

Moi c'est Mickaël, 39 ans, habitant à la Roche sur Yon en Vendée.

 

Intéressé depuis longtemps par les nouvelles technologies, je ne suis tombé dans la robotique que récemment, qui est devenu actuellement mon hobby principal !

 

Je dispose de bases en électronique, mécanique et programmation (arduino, python), sans être un expert non plus.

 

Pour l'instant, je suis un peu touche à tout (arduino, raspberry, lego mindstorm EV3, imprimante 3D, etc), pour découvrir le panel des possibilités offertes et j'apprends au fur et à mesure de quelques petits projets simples (robot Otto, robot mobile autonome, bras robotisé...), mais je compte bien me lancer dans des projets plus ciblés (quelques idées, mais tout reste ouvert) et en profiter pour communiquer le virus à mes enfants !

 

A bientôt

Mickaël