Version actuelle datée du 27 mai 2019 à 01:05

Prélude

Nous avons choisis la proie, nous voudrions appuyer notre travail sur la progammation et le design du support.

Même si ça sera expliqué plus tard : Pour le design du système, nous avons choisi de copié la RAY MANTA et le BLAIREAU. Pour la carte, nous reprendront un modèle de l'année précédente. Pour le moteurs nous aimerions utiliser ceci

Nous sont imposés : - L'utilisation d'une ATMEGA328P ou d'une ARDUINO

Historique de travail

Nous avons d'abord décidé d'adopter un mode de travail classique; Correspondant à celui qu'avaient mis en place les autres bureaux d'études avant nous. Soit un compte rendu séance par séance du travail effectué sur le projet;

cependant, nous travaillions sur le projet hors des séances et les comptes rendus, en plus de sembler hors contexte se ressemblaient tous. Nous avons alors décidé d'adopter une méthode de travail plus agile;

Exprimer les fonctions du système;
Trouver des solutions techniques nous permettant de répondre aux fonctions;
Tester les solutions de manière théorique, par expérience de penser ou de manière physique;
Recommencer jusqu'à obtenir un système correspondant aux fonctions désignées.

Nous décrivons donc ci-dessous le raisonnement ayant conduit au choix d'une solution technique particulière pour répondre à un problème posé par une/des fonction/s du système. Ensuite le choix fait pour le prototypage.

Expression des fonctions du système

Les fonctions que doit remplir le robot sont :

F1 - Se déplacer dans l'espace
F2 - Communiquer avec le PREDATEUR

Nous avons décidé d'ajouter à ces deux fonctions

F11 - Eviter les obstacles
- F111 - avoir conscience de son environnement proche
- F112 - se déplacer rapidement
F21 Connaitre l'état de la chasse (capturé ou non)
- F211 - Lire les signaux envoyés par le PREDATEUR

Nous voulions ajouter un EASTER EGG (NOTE OISEAU)

f1 - Cri lors de la fuite
- f11 - fréquence constante
- f21 - augmentation et diminution lente du volume

Fonction Première 1 - Se Déplacer dans l'espace

Moteur 6V 100RPM.

Nous avons ici choisi la solution qui nous paraissait la plus simple, deux moteurs, pour deux roues; ainsi qu'une roue folle.

La variation de la vitesse de rotation des moteurs ne nous semble pas un paramètre important; il est plus important de mettre de la distance entre la PROIE et le PREDATEUR; ainsi la proie doit être légère et rapide;

Nous avons donc chercher des moteurs peu volumineux et léger, notre choix se porte sur le moteur 6V 100RPM

À ce moteur seront attachée des roues, désignée plus tard dans le projet; l'idéal serait d'avoir une vitesse maximale de 1 km/h (16.6m /min); les roues devront alors faire au moins 5 cm de diamètre.

La commande des moteurs sera assurée par la carte électronique fournie

Fonction Secondaire 1 - Pouvoir éviter les obstacles

Avoir conscience de son environnement proche

Ici aussi, la solution envisagée a été simple; celle-ci proposée par le projet. L'utilisation de capteur ultrasonore.

Après une expérience de pensée nous avons décidé d'utiliser 3 CAPTEURS ULTRASONORES; repartis en arc de cercle à l'avant du véhicule ils devraient pouvoir nous permettre, dans un rayon de quelques mètres et avec un angle effectif de mesure de bientôt 100°, de pouvoir détecter les obstacles proches;

Un problème se pose à ce niveau, l'ATMEGA328P, a un nombre très limité de pin. La solution envisagée est d'utiliser les mêmes pins pour VCC, GRND et TRIGGER, sur les 3 CAPTEURS ULTRASONORES. Un premier testé sur une Arduino nous montre qu'il est possible dans nos conditions d'utiliser les 3 capteurs de cette manière.

const byte TRIGGER_PIN = 7; // PIN TRIGGER
const byte ECHO_PIN_1 = 3;    // PIN ECHO 1
const byte ECHO_PIN_2 = 4;    // PIN ECHO 2
const byte ECHO_PIN_3 = 4;    // PIN ECHO 3
 
/* Constantes pour le timeout */
const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s

/* Vitesse du son dans l'air en mm/us */
const float SOUND_SPEED = 340.0 / 1000;

void setup() {
   
  /* Initialise le port série */
  Serial.begin(115200);
   
  /* Initialise les broches */
  pinMode(TRIGGER_PIN, OUTPUT);
  digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
 pinMode(ECHO_PIN, INPUT);
} 

void loop() {
 //ECHO 1
 /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
 digitalWrite(TRIGGER_PIN, HIGH);
 delayMicroseconds(10);
 digitalWrite(TRIGGER_PIN, LOW);
 
 /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
 long measure = pulseIn(ECHO_PIN_1, HIGH, MEASURE_TIMEOUT);
  
 /* 3. Calcul la distance à partir du temps mesuré */
 float distance_mm = measure / 2.0 * SOUND_SPEED;
  
 //ECHO 2
 /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
 digitalWrite(TRIGGER_PIN, HIGH);
 delayMicroseconds(10);
 digitalWrite(TRIGGER_PIN, LOW);
 
 /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
 long measure = pulseIn(ECHO_PIN_2, HIGH, MEASURE_TIMEOUT);
  
 /* 3. Calcul la distance à partir du temps mesuré */
 float distance_mm = measure / 2.0 * SOUND_SPEED;
  
 //ECHO 3
 /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
 digitalWrite(TRIGGER_PIN, HIGH);
 delayMicroseconds(10);
 digitalWrite(TRIGGER_PIN, LOW);
 
 /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
 long measure = pulseIn(ECHO_PIN_3, HIGH, MEASURE_TIMEOUT);
  
 /* 3. Calcul la distance à partir du temps mesuré */
 float distance_mm = measure / 2.0 * SOUND_SPEED;
 /* Délai d'attente pour éviter d'afficher trop de résultats à la seconde */
 delay(500);
}

Se déplacer rapidement

Il faut pour que la PROIE puisse se déplacer rapidement que vitesse linéaire soit importante mais aussi que la vitesse en rotation soit importante.

La vitesse linéaire théorique est celle que nous nous étions imposé 1 km/h; la vitesse en rotation elle va dépendre de l'écart entre les deux roues; la roue folle entre alors en jeu; cette roue folle nous sert à la fois d'appui, pour rendre le système isostatique (On considère les contacts des roues comme ponctuels) et de 3 iem roue;

Nous allons la placer la plus loin possible de l'axe des deux roues motrices.

Fonction Première 2 - Communiquer avec le prédateur

Pour communiquer nous utiliserons les capteurs et émetteurs infrarouges mis à notre disposition; nous ne pouvons pas faire autrement car tout le monde doit pouvoir communiquer et lire sur le même canal de transmission. Nous n'avons pas pu décider avec les autres groupes d'une nomenclature du signal envoyé via l'infrarouge, nous émettons alors en continue.

Fonction Secondaire 2 - Connaitre l'état de la chasse (capturé ou non)

Lire les signaux envoyés par le PREDATEUR

Pour pouvoir lire les signaux envoyés par le PREDATEUR, il faut se mettre d'accord avec les autres groupes sur la nomenclature du message; ça n'a pas été possible alors, au lieu de lire un message transmis via l'infrarouge nous allons lire l'intensité du signal infrarouge reçu.

Fonction EE - CRIER

L'émission d'un son nécessite la présence d'un émetteur, un haut parleur. On pourra connecter le haut parleur à une sortie digital et utiliser ce code ci pour émettre le son : (DEPUIS ARDUINO)

int speakerPin = 8;
unsigned long ringtime = -300000;
long dectime = 300000;
unsigned long limit = 395973836; // 80% max usigned long SOIT 10 jours avant
int length = 15; // the number of notes
char notes[] = "2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2"; // a space represents a rest
int beats[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, };
int tempo = 300;
void playTone(int tone, int duration) {
  for (long i = 0; i < duration * 1000L; i += tone * 2) {
    digitalWrite(speakerPin, HIGH);
    delayMicroseconds(tone);
    digitalWrite(speakerPin, LOW);
    delayMicroseconds(tone);
  }
}
void playNote(char note, int duration) {
  char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
  int tones[] = { 1915, 1915, 1915, 1915, 1915, 1915, 1915, 1915 };
  // play the tone corresponding to the note name
  for (int i = 0; i < 8; i++) {
    if (names[i] == note) {
      playTone(tones[i], duration);
    }
  }
}  

void setup() {
  Serial.begin(9600);
  pinMode(speakerPin, OUTPUT);
}
void loop() {
      for (int i = 0; i < length; i++) {
        if (notes[i] == ' ') {
        delay(beats[i] * tempo); // rest
        } else {
          playNote(notes[i], beats[i] * tempo);
        }
      delay(tempo / 2);
      }
  delay(60);        // delay in between reads for stability
}

Prototypage

Conception Mécanique

Après beaucoup de travail voici le schéma technique réalisé pour le châssis et les supports capteurs. Fichier:1920B6 chassis.pdf

Les fichiers 3D sont disponibles sur le drive. LES VISUALISATIONS EN INDEX !

Châssis

Après avoir établi certaines règles, le prototype ressemble à : On y trouve, de quoi solidariser les cales motrices, le PCB et le support CAPTEUR ULTRASON au châssis. Le dessin effectué en 3D et ensuite exporté pour être découpé sur une découpeuse LASER, les fichiers de découpe se trouvent sur le drive;

Cales Moteurs et Batteries

Les moteurs que nous avions choisis n'ont pas pu nous parvenir à temps, nous avons donc choisis d'autre moteurs pour le prototype; Nous avons alors augmenté la surface occupée par les moteurs sur le châssis et diminuer celle des CAPTEURS ULTRASONORES. Les cales moteurs sont alors désignés pour les moteurs disponibles et ressemblent à :

La batterie est une partie du système à laquelle nous n'avions pas pensé; nous avons pu en récupérer une et avons désigné les cales suffisantes ; Les cales côtés représentent les yeux et le cache avant, un museau.

Roues

Les roues fournies avec les moteurs sont un peu lourde, nous avions en tête d'en réaliser de nouvelles mais nous n'avons pas pu :

Support INFRAROUGE

L'émetteur et le capteur Infrarouge doivent se situer à l'arrière pour que la lumière émise soit facilement visible par la proie et que le capteur puisse avoir un retour fiable de l'intensité de la lumière infrarouge qui lui parvient. Des photos du montages sont disponibles sur le drive;

Support CAPTEUR ULTRASONORE

Avec la perte de place qu'impose les moteurs utilisés nous avons dû diminuer la place des CAPTEURS ULTRASONORES; une solution envisagée pour garder 3 capteurs dans un espace aussi petit et de les mettre à l'horizontale, cependant aucun test n'a encore été fait; le prototype n'aura donc qu'un seul capteur.

Partie PCB

Un objectif de ce projet était de designer notre propre carte PCB pour gérer les capteurs et les moteurs du robot sans passer par une carte Arduino. Pour designer notre carte, nous avons utilisé le logiciel Fritzing et sommes partis de la carte standard fournie par les enseignants.

Il nous a fallu plusieurs séance avant de maitriser Fritzing. Nous avons tout d'abord eu à choisir les fonctionnalités du robot que nous souhaitions implémenter (combien de capteurs infra rouge ? d'émetteur-récepteur ultra son ?) puis nous avons modifié la carte en fonction de manière à prendre en compte ces contraintes (réattributation des entrées / sorties des ports digitaux / analogiques du micro-controlleur).

Une fois les fonctionnalités de la carte fixées, nous avons re-routé le PCB, c'est-à-dire réarrangé le tracé des fils électriques reliant les composants de la carte de telle manière que deux fils ne se croisent pas.

Nous avons effectué une première tentative de routage mais nous avons ensuite appris qu'il fallait favoriser des angles de 45°, utiliser des largeurs de fils plus petites pour faciliter le routage et prendre en compte le Design Rule Check. En prenant en compte toutes ces contraintes, nous sommes finalement parvenus à une carte fonctionnelle prête à être imprimée.

Après l'impression, il nous a fallut souder la majorité des composants de la carte. Tâche qui s'est révélée difficile de par la précision requise lors de la manipulation des composants. Cela nous a permis, entre autre, de nous familiariser avec la soudure.

Partie Code

Nous nous sommes également chargés de la programmation du robot. Pour cela, nous avons utilisé le logiciel d'Arduino qui nous a permis de programmer et de téléverser le programme sur la carte. Idéalement, le programme permettrait de faire se déplacer le robot en se basant sur trois capteurs ultra-sons orientés à l'avant du robot et espacés d'un angle d'environ 45°. Dès que la distance d'un des capteurs devient inférieure à un seuil donné, le robot choisit, selon la situation, de: tourner, si la distance indiquée par les autres capteurs le permet reculer, si les autres capteurs indiquent une distance également inférieure à un seuil donné, jusqu'à ce que la distance repasse au dessus du seuil, puis tourner pour ne plus emprunter le même chemin.

Il serait également possible pour le robot d'anticiper un obstacle en tournant légèrement lors du déplacement lorsqu'il perçoit que la distance d'un des capteurs ne fait que diminuer (cette fonctionnalité se déclencherait même si la distance devait supérieure au seuil mentionné plus haut).

Nous aurions aimé pouvoir implémenter ce programme. Seulement, il fallait tout d'abord s'assurer d'avoir une carte fonctionnelle. Sans celle-ci, nous n'aurions pas pu tester le dit programme pour paramétrer les seuils, définir les sens de rotations des moteurs, etc. Or, la confection de cette carte nous a pris plus de temps que prévu, et malgré que le programme existe, nous n'avons pas pu le faire fonctionner sur le robot dans le temps imparti.

De plus, une erreur de conception de la carte pcb nous empêchait de brancher directement les 3 capteurs ultra-sons les uns à coté des autres (manque de place), c'est pourquoi nous nous sommes finalement rabattus sur un programme plus simple du type: tant que distance au capteur > seuil : avancer , sinon : tourner

Difficultés rencontrées: - Prise en main de Fritzing - Court circuits lors du design du schematic - Routage de la carte en prennant en compte toutes les contraintes - Soudure des composants de petites tailles

Réalisation

Nous n'avons pas réussi a finaliser notre prototype à l'heure; Une vidéo sera bientôt ajouté sur le drive, montrant le bon fonctionnement du système.

Annexes

Doc

https://drive.google.com/open?id=1UDdSN7vpYbM39y0_cQ93cMxDE6epYX1h

Outils utilisés

Fritzing avec le modèle fournit en début de projet
Fusion 360 License étudiant, pour la modélisation du chasis
Edge parce que on a vraiment aucun respect pour le web

Visualisation

Moteur Utilisés.
Moteur Utilisés.
Cales Moteurs
Cales Batterie
Roue
Support Infrarouge
Support CAPTEUR ULTRASONORE

Notes

Oiseaux

Les oiseaux utilisent un système similaire pour qu'on ne puisse pas connaitre leur position simplement en les entendant siffler; En effet le cerveau des mammifères superpose les sons arrivant dans les deux oreilles et en fonction des différences peu déduire la position relative de l'objet sonore. Si le son a une fréquence constante, il est plus difficile de trouver des points aux quels faire la différence de l'arrivé des signaux; et on ne peut déduire la position de l'objet

Binome2018-6 : Différence entre versions