edwige.calmon@etu.upmc.fr

edene.rocheron@etu.upmc.fr

Concevoir un objet interactif/connecté en utilisant des capteurs et autres composants ARDUINO à partir d'une carte ARDUINO UNO ou autre.

Pour cela nous allons réaliser un robot, qui sera capable de ce mouvoir dans un espace et éviter les obstacles grâce à un capteur infrarouge.

- Concevoir un robot de petite taille (- de 800g)

- Robot qui puisse avancé - Robot qui puisse prendre connaissance des obstacles - Robot qui puisse reculé et bifurquer en cas d'obstacles

- Utilisation un maximum de matériau de recyclage

- Utilisation facile

- Garder l'authenticité de la robotisation (design vintage)

- Carte ARDUINO UNO

- 2 MOTEURS continus DC pour chaque roue (2 roues motrices) situés à l'avant de l'appareil. UPDATE : 2 moteurs continus DC 6-15 V 457RE360

- Choix d'un double pont H L293D pour utiliser 2 moteurs distincts (dans un seul sens) grâce aux nombreux canaux. De plus il se comporte comme 2 ponts H. On peut aussi faire fonctionner les 2 moteurs dans 2 sens différents.

- JUMPERS câble de raccordement.

- Une BREADBOARD pour le circuit et relier tous les éléments.

- 2 ROUES en polymère réalisées grâce à l'imprimante 3D.

- Support pour I_ROBOT en plexiglas découpé au laser.

- Capteur VL53LDK Mesure de distance Infrarouge (très fragile)

- Capteur TCRT5000 Mesure de distance Infrarouge

#include <I_Robot.h>
int GA=11,GB=10,DA=5,DB=6; //initialisation des pins
void setup() 
{
Serial.begin(9600);
pinMode(DA,OUTPUT);
pinMode(DB,OUTPUT);
pinMode(GA,OUTPUT);
pinMode(GB,OUTPUT);
}
void ar() //arriére
{
digitalWrite(DA,HIGH);
digitalWrite(DB,LOW);
digitalWrite(GA,HIGH);
digitalWrite(GB,LOW);
}
void av() //avant
{
digitalWrite(DA,LOW);
digitalWrite(DB,HIGH);
digitalWrite(GA,LOW);
digitalWrite(GB,HIGH);
}
void g() //gauche
{
digitalWrite(DA,LOW);
digitalWrite(DB,HIGH);
digitalWrite(GA,HIGH);
digitalWrite(GB,LOW);
}
void d() //droite
{
digitalWrite(DA,HIGH);
digitalWrite(DB,LOW);
digitalWrite(GA,LOW);
digitalWrite(GB,HIGH); 
}
void loop() {
av();
delay(5000);
ar();
delay(5000);
g();
delay(5000);
d();
delay(5000); 
}

 #include "Adafruit_VL53L0X.h"
 Adafruit_VL53L0X lox = Adafruit_VL53L0X();
 void setup() {
 Serial.begin(115200);
 // wait until serial port opens for native USB devices
 while (! Serial) {
 delay(1);
 }
 Serial.println("Adafruit VL53L0X test");
 if (!lox.begin()) {
 Serial.println(F("Failed to boot VL53L0X"));
 while(1);
 }
 // power 
 Serial.println(F("VL53L0X API Simple Ranging example\n\n")); 
 }
 void loop() {
 VL53L0X_RangingMeasurementData_t measure;
 Serial.print("Reading a measurement... ");
 lox.rangingTest(&measure, false); // pass in 'true' to get debug data printout!
 if (measure.RangeStatus != 4) {  // phase failures have incorrect data
 Serial.print("Distance (mm): "); Serial.println(measure.RangeMilliMeter);
 } else {
 Serial.println(" out of range ");
 } 
 delay(100);
 }

// the setup routine runs once when you press reset:
void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);}
// the loop routine runs over and over again forever:
void loop() {
  // read the input on analog pin 0:
  int sensorValue = analogRead(A0);
    // print out the value you read:
    Serial.println(sensorValue);
    delay(100);}        // delay in between reads for stability

//pins initalisation
int GA=11, GB=10, DA=5, DB=6;
// the setup routine runs once when you press reset:
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
pinMode(GA,OUTPUT);
pinMode(GB,OUTPUT);
pinMode(DA,OUTPUT);
pinMode(DB,OUTPUT);
             }
void ar() //moving back {
digitalWrite(DA,LOW);
digitalWrite(DB,HIGH);
digitalWrite(GA,LOW);
digitalWrite(GB,HIGH);
                        }
void av() //moving forward {
digitalWrite(DA,HIGH);
digitalWrite(DB,LOW);
digitalWrite(GA,HIGH);
digitalWrite(GB,LOW);
                           }
void d() //right {
digitalWrite(DA,LOW);
digitalWrite(DB,HIGH);
digitalWrite(GA,HIGH);
digitalWrite(GB,LOW);
                 }
void g() //left {
digitalWrite(DA,HIGH);
digitalWrite(DB,LOW);
digitalWrite(GA,LOW);
digitalWrite(GB,HIGH); 
                }
// the loop routine runs over and over again forever:
void loop() {
int sensorValue=analogRead(A0);     // read the input on analog pin 0:
// print out the value you read:
Serial.println(sensorValue);
delay(1);        // delay in between reads for stability
// conditions for the sensor to avoid obstacles
if (sensorValue>700) {
av();
delay(3000);
                     }
if (sensorValue<700) {
ar();
delay(2000);
g();
delay(2000);
                     }
            }

- roues qui patinent au contact du sol. Il est important de concevoir des roues qui ne soient pas LISSES mais qui ACCROCHES Ce problème implique que le robot ne ce déplace pas de façon idéal sur le sol

- Avoir un bon équilibre. Poids/Roues On a crée de grosses roue pour maximiser l’accroche au sol, mais les composant obligatoire comme l'arduino ou la board crée beaucoup de poids.

- Syncronisation des moteurs Un shield pour gérer la vitesse des roues aurait été nécessaire. On a pas pu avoir cette pièce. Les réglages électroniques ne compensent pas assez ce manque.

- Réducteur de vitesses pour que le capteur prennent le temps de visualiser l'obstacle Shield nécessaire.

- Beaucoup trop lourd avec les 2 étages On a du repasser à un châssis unique

- VL53LDK fragile Le capteur de remplacement n'est pas aussi performant que l'ancien. Le robot détecte l'obstacle trop tard et n'évite donc pas l'obstacle. Il réagis néanmoins à sa présence et envoi le signale d'évitement pour reprendre sa trajectoire.

- moteur DC 5V manque de puissance Le robot est trop rapide sur certains moments et pas sur d'autres.

- pile défectueuse La pile utilisé fait varier la puissance du moteur.

Prototypage

- On commence par une maquette du robot. On sait qu’on a besoin d’un arduino, d’une bredboard et de 2 moteurs minimum :

- On récupère donc une chute de plaque de plexiglas de forme rectangulaire pour poser notre montage.

- On crée des roues en carton avec la découpe laser rapide, pour ce rendre compte de la taille nécessaire, des fixations et pour tester la vitesse des moteurs. On découpe des cercles dans du carton avec la découpeuse laser. On assemble les bouts pour crée une roue épaisse, on les « fixes » au moteur.

- On trouve 2 moteurs continus DC : ils sont petits et léger donc bien pour le robot. Un engrenage ce trouve au bout : on peut utiliser le support fournis dans le kit arduino pour faire le liens avec les roues, mais après test, la vitesse des moteurs expulse les roues de l’engrenage. On recherche donc d'autres solutions de fixation roue / moteur.

On monte le tout :

- Ce n’est pas très stable mais ça tiens debout - On ajoute une cale à l’avant pour contre balancer l’effet de poids : pour cela on fixe une vise avec des rondelles pour simuler une roue avant.

- On crée le 1er programme de notre robot : code 1. Il contrôle les moteurs - Tests sur le fonctionnement du code1, le moteur tourne trop rapidement : il faut le ralentir et avoir le contrôle sur la vitesse. Pour cela, le mieux serait d'avoir un Shield adapté mais nous n'en avons pas a disposition.

On fait un montage simple pour ce 1er prototype.

Capteur :

- On choisis notre capteur pour détecter les obstacles. On utilise un capteur miniature infrarouge VL53LDK pour mesurer la distance d'un obstacle avec une grande précision.

- Élaboration d'un programme pour le capteur VL53L0X. Code 2.

- Test du code sur le capteur et sur l'ARDUINO : SUCCES

Châssis :

- On passe à la réalisation d’un châssis en plexiglas.

On décide de faire un robot sur 2 étages pour minimiser la taille, on empilant les pièces sur la hauteur grâce aux étages.

Pour cela on prend les mesures exactes de chaque pièce qui compose notre robot et on les recrée à l’échelle sur Inkscape. On peu alors crée notre châssis à la bonne taille sans soucis de mesure ou d’échelle.

On fait alors nos 2 châssis identiques découper à la découpeuse laser.

Les roues :

On a besoins de remplacer les roues faites en carton par des roues fonctionnelles. On ne dispose pas de roue en caoutchouc en bon état ou par paire. On doit donc crée nos roues de toutes pièces. On choisis un model imprimable en 3D en accès libre pensent que la modélisation 3D est compliquer à mettre en oeuvre. Au cours des séances on se rend compte qu'on auraient put les modéliser nous mêmes, mais les roues étant déjà imprimés il n'y avait pas d'utilité à en refaire de nouvelles.

- On imprime donc les roues en 3D pour remplacer celles en carton. On choisit de faire des roues de 5.5cm sur 2cm de large. On ne peut en imprimer qu'une seul lors de cette séance à cause du temps d'impression de 4h.

- Roue no.1 en cours d'impression :

Montage :

- On vois que les moteurs sont très rapide. On cherche donc à réduire leur vitesse grâce a la modification du code 1.

- On simplifie le montage en diminuant le nombre de câble.

- On ajoute notre capteur miniature infrarouge VL53LDK à notre montage.

Châssis :

Pour monter les 2 étages de châssis ensemble il nous faut des fixations. On crée donc des cylindres en 3D afin de crée l'espace suffisant pour le double niveau, cela permet de tenir la structure entre les 2 châssis. Les cylindres sont creux pour accueillir des visses et font 50mm de haut pour laisser la place aux composants.

Roues :

- On imprimer également la 2iem roue qui ne pouvait pas être imprimer en une seule fois.

- On trouve 2 roues mobiles supplémentaires pour l'équilibre. Notre robot sur 2 roue n'est pas stable il faut donc l'équilibrer avec des roues de soutiens. On fixe les roue supplémentaire sur l'avant et une autre à l’arrière. Ces roues lourdes ajoutent du poids, en effet ce sont des roulement à billes.

Code :

- Revérification et FUSION des 2 codes ARDUINO

En ce jour, reconnaissance des problèmes sur le ROBOT.

Problème poids et roues :

- Premier test sur le robot : avec l'ajout de toutes les pièces + la batterie externe pour l'alimenter sans être relier à un ordinateur, on ce rend compte qu'il est plutôt lourd. Son poids est de plus de 447 grammes avec les 2 étages (arduino + breadboard + batterie), les moteurs ne suivent plus, et ne permettent pas au robot d'avancer correctement.

- De plus, les roues sont très lisses et donc patines : le robot a une mauvaise accroche au sol ce qui n'aide en rien les moteurs. L'imprimante 3D nous donne des objets en polymère (ainsi vraiment lisse) et pas forcément adapter pour des roue. Pour tenté de résoudre le problème on test avec des élastiques en caoutchouc autour des roues, mais ça n'aide pas plus que ça le robot. On les enlèves donc.

Idée

- Nous essayons donc de mettre 2 moteurs supplémentaires afin d'avoir 4 moteurs qui alimenterait 4 roues et impliquerai donc plus de puissance. Tout en faisant toujours attention a ne pas modifier le système de rotation “droite”, “gauche”

- On repasse donc sur un robot sur un seul étage pour mieux répartir le poids et ainsi pouvoir installer les 4 roues pour 4 moteurs. PAS BESOIN DE 4 ROUES ON A REMARQUER QUE LE PROBLEME EST AU NIVEAU DE LA PILE 9V

- De plus, pour la fixation roue / moteur, on a toujours pas trouver de solution pour fixer l'engrenage à notre roue. On essaye de crée une pièce d'engrenage sur mesure, mais c'est très compliquer au vu de la toute petite taille de la “roue” au bout de notre moteur. De plus le logiciel de modélisation d'engrenage ne permet pas de faire de “roue” au centre d'une pièce mais seulement sur les contours.

Design :

- On commence également à travailler sur le design du robot. On modélise donc toutes les pièces qui le compose non plus en dessin vectoriel mais en 3D grace à TinkerCad, afin de pouvoir concevoir un habillage à l'échelle. L'idée initiale était de faire une figurine par dessus notre robot mais au vu des composants, il vaut mieux mettre une coque externe afin de cacher les branchements et d'éviter les problèmes d'équilibre avec un poids répartie uniformément, ce qui n'est pas forcement possible avec une figurine.

Moteurs :

- Vu que nos moteurs ne sont pas assez puissant et ont un système d'attache pas très adapté à nos roues, on cherche donc de nouveau moteurs plus puissant afin que note robot avance mieux, et également potentiellement trouver un système de fixation compatible avec nos roues. On cherche des moteurs supplémentaires au fablab, on trouve des moteurs plus puissants pour une taille raisonnable. On fait donc des tests. (utilisation moteur DC plus puissant 9-15V 457RE360)

- Problème : on voit une différence de vitesse entre les 2 moteurs qui sont identiques. En effet les roues ne tournent pas à la même vitesse. On réalise plusieurs tests et on voit que c’est à cause des piles 9V. Elles ne doivent pas avec la même réserve d’énergie. On décide alors de centraliser notre source d’énergie, et on relie les 2 moteurs à une unique pile. Notre pile donne quand même une force faible à nos 2 moteurs.

On choisit quand même d’utiliser ces moteurs car plus puissant donc plus adaptés pour supporter le poids des pièces.

- Les nouveaux moteurs sont plus lourd et plus gros : la colle ou le scotche ne permet pas de les fixer correctement. Ces nouveaux moteurs sont directement relier à une plaque métallique prête à visser.

Châssis :

- On refait donc un nouveau châssis pour accueillir toutes les pièces sur un seul étage. Et on cherche à ajouter des “trous” sur le châssis afin de pouvoir visser la plaque des moteurs sur le châssis et éviter la colle ou le scotch. PROBLEME : DECOUPEUSE LASER CASSÉE/INDISPONIBLE, on reporte donc la découpe à plus tard.

Code :

- On adapte le code pour qu’il puisse fonctionner sur les nouveaux moteurs.

Design :

- On avance sur la modélisation de la carrosserie du robot. On opte pour une forme de voiture. C'est la forme qui permet de mieux camoufler les branchements tout en permettant de glisser la batterie portable à l’intérieur du dispositif et ainsi rendre le robot totalement autonome au sol.

- Problème : pour l’impression de la carrosserie, l’impression à une durée de 27h04, ce qui est trop long. On essaye de réduire le temps d’impression en affinant la carrosserie et en ajoutant des emplacement vide.

Moteurs :

- Les nouveaux moteur DC 9-15 Volt beaucoup plus puissant et donc rapide sont parfait pour notre robot

- On achète une nouvelle pile neuve (adapté et pleine) pour que les 2 moteurs puissent avoir la même énergie et donc avoir des tours de rotations identiques.

- le robot s'active correctement, marche correctement grâce au CODE, avance correctement

- robot très énergique ! ahah

- Micro tests d'avancement au FabLab

Design :

- On à diminué au maximum le temps d'impression 3D pour notre carrosserie en essayant de la faire la plus fine possible. Un emplacement pour le capteur est prévue à l'avant de la “voiture”. La puce responsable d'envoyer le signal est de quelque millimètres. On fait donc un trous très discret. On compte scotcher le capteur à l’intérieur et laisser uniquement la dispositif infrarouge passer au niveau du trous.

Après modélisation final on peut alors lancer l'impression.

RENDU REPORTÉ : on peut donc mieux finaliser noter robot.

Châssis :

Les emplacement pour les visses des plaques moteurs ont été faites sur mesures.

Mais notre dernier croquis de châssis est carré sur les angles. Il faut donc réussir à trouver les mêmes mesures d'angles de la carrosserie pour que note châssis soit compatible.

Pour cela on convertie note châssis modélisé en 3D sur TinkerCad d'un fichier STL en fichier SVG 2D dessin vectoriel afin d'avoir des angles qui correspondent à l'angle de notre carrosserie et de pouvoir l’ouvrir sur Inkscape.

La découpeuse laser est réparer, on peut donc découper notre châssis final. Le châssis final est donc terminer.

Carrosserie :

Malgré une modélisation non professionnel, la carrosserie est imprimé exactement comme attendue. Elle s’emboîte bien sur le châssis. Des points de colle sur les rebords interne de la carrosserie permettra une bonne attache du châssis sans pour autant que celle-ci soit inenlevable si nécessaire.

Les “trous” pour faire un effet de vitre permettent aussi de pouvoir manipuler les composants interne si besoins sans avoir besoin de détacher la carrosserie du châssis. Ex : si un fil ce détache ou pour brancher la batterie. On peut également glisser la batterie à l’intérieur de la carrosserie grâce à la grosse “vitre” arrière.

Si on veut totalement camoufler l’intérieur de la voiture on peut même venir coller des feuilles blanche ou des feuilles imprimer avec des intérieurs de voiture, sur la partie interne de la carrosserie.

- Cette semaine le capteur grillé à cause des soudures -_-“

- On cherche donc un nouveau capteur. Il n'y a plus de capteur identique au notre de disponible au fablab. On doit donc trouver un capteur alternatif.

- On arrive à trouver un capteur TCRT5000 qui se rapproche le plus du comportement de notre ancien capteur VL53LDK. C'est un capteur infrarouge également. Cependant il à un temps de réponse bien plus long que l'ancien capteur ce qui n'aide pas pour éviter les obstacles, et il a une distance de détection plus courte (environ 10cm). Il est donc moins efficace et moins adapté à notre robot.

- Le capteur fonctionne quand même correctement pour ses caractéristiques. - On n'a pas rencontré de difficulté de connectique lors du changement de capteur.

• On monte alors notre robot :

PROBLEME : le robot n'avance pas. En effet le gros châssis + les pièces + la carrosserie rend le robot beaucoup trop lourd.

- Repasser le robot sur un seul étage implique un châssis plus grande, cela ne diminue pas assez le poid du robot : il a toujours du mal à avancer. Il pèse toujours bien plus que notre 700/800 grammes MAX pour la puissance des moteurs.

- On remarque qu'aléatoirement il ce bloque et reste sur place. Ensuite il ce met en marche tout à coup et fonce dans les obstacles car le capteur n'a pas le temps d'envoyer l'information :STOP:

- De plus le fait d'avoir changer de capteur (celui-ci est fixe, alors que l'autre pouvait être déplacer) fait qu'on ne peut pas mettre la coque en 3D car sinon elle recouvre le capteur et bloque donc le signal. Le changement obligatoire de capteur à la dernière minute implique donc qu'on ne peut donc pas utiliser la carrosserie prévue.

- Même sans la coque il a beaucoup de mal à ce déplacer. On décide alors de ne plus poser la batterie portable sur le robot mais de la tenir à la main à distance. Cela soulage un peu le poids.

- On décide donc de monter le robot sur le tout premier châssis réalisé qui était très compacte afin de réduire l'espace au maximum et d'optimiser la répartition du poids.

On arrive alors à le faire marcher. Les test ne sont pas comme on l’espérait mais il fonctionne :

RENDU

Le robot n'évite pas les obstacle du à sa vitesse absolument pas constante.

Cependant le reste fonctionne très bien :

- Le robot détecte l'obstacle - Le signal est envoyé (trop tard certes) - Le robot recule alors pour éviter l'obstacle. - Il effectue un demis tour - Il reprend sa trajectoire jusqu’à rencontrer un autre obstacle. - boucle

Difficultés rencontrés :

• Changement de capteur à la dernière minute pour un capteur moins adapté

• Pas de shield pour contrôler la vitesse des moteurs

• Poids du robot trop lourd à cause des composants “maisons”

• Conception de A à Z. L'idéal aurait été de trouver un “reste” de voiture robot et de nous concentrer uniquement sur la partie électronique : capteurs / GPS / travail sur la trajectoire à suivre / meilleur évitement d'obstacle etc.

- On aurait alors pu équiper note robot de bien plus de fonctionnalités et de rencontrer moins de problèmes qui ralentissent la pluridisciplinarité de notre robot.

Photos prototype final :

Photo prototype final espéré sans contraintes :