Complication et achèvement du projet – Jour 5

Comme j’ai été super excité de finir le projet, j’ai complètement oublié de construire une base à laquelle rattacher les roues avant et arrière ainsi que les moteurs et la pile… J’ai donc créé une autre base.

minibase du Robolight     

mininouvelle_base

J’ai eu un énorme problème à fixer le servomoteur avec la structure soutenant la roue avant car les engrenages faient à la découpeuse laser avaient des dents trop fines pour du médium de 3mm et ont commencé à s’effriter. J’ai donc dû utiliser une pièce plastique (vendue avec le servo) comme extension pour fixer les deux éléments ensemble.

J’ai principalement utilisé de la colle à bois, pistolet à colle et superglue pour assembler le robot. J’ai également attaché le moteur via des tiges de sécurité et la batterie est maintenue grâce à 3 aimants.

Voici à quoi ressemble le robot une fois monté.

  miniRobot_vue_de_profil

miniRobot_vue_de_dessous minirobot_vue_de_dessus

J’ai également rajouter un petit interrupteur pour me permettre d’activer le robot quand je le souhaite.

Voilà, j’espère que ce projet a été aussi intéressant à lire que pour moi à le réaliser.

Si vous avez des conseils à me donner sur des éléments que vous jugez possible à améliorer ou carrément à réaliser, n’hésitez pas à laisser un commentaire ^^

Je mettrais bientôt une vidéo de son fonctionnement mais la courroie de transmission entre le moteur et les roues de derrières n’est pas assez tendue, après avoir régler ce dernier détail, le robot devrait être opérationnel.

La structure du robot – Jour 4

Pour construire mon robot, j’ai tracé les pièces dont j’avais besoin sur inkscape et puis j’ai utilisé la cutter laser pour obtenir les éléments à partir d’une plaque de médium 3mm.

Inkscape :

Voici les plans sur Inkscape :

plan_robolight(Il manque les trous pour faire passer l’engrenage du servo sur les sortes de planches de surf… C’est paaaas bien)

Quelques petites astuces :

  • Pour faire des engrenages, il faut aller dans Extensions -> Rendu et cliquez sur Engrenage…  Une boite de commande va apparaître permettant de séléctionner le nombre de dents que l’on veut à notre engrenage, la taille de l’engrenage et l’aspect des dents.
  • Pour découper les pièces via un cutter laser, il faut que l’épaisseur des traits ait une valeur précise (inférieure ou égale à 0,1 mm). Pour choisir cette caractéristique, il faut aller dans Objet -> Remplissage et contour… -> Une boite d’outils apparaîtra et il faut cliquer sur Style du contour. Là vous pourrez choisir l’épaisseur de votre trait.
  • Pour déplacer les éléments entre eux (pour réussir à centrer les trous au milieu du cercle par exemple), le raccourci clavier est ctrl + maj + a pour ouvrir une boite d’outils qui va nous permettre de le faire. Sinon, le chemin à suivre est Objet -> Aligner et distribuer…

Voici ce que ça donne une fois les pièces montées. En revanche, il va falloir que je retravaille la base du robot.

minibase_roues

Les soudures – Jour 3

Ce post n’a pas grand interêt mais après toutes ces lignes de code, un peu d’images sont bienvenues ^^

miniSoudure

On voit les deux LDR soudées à leur board (en symétrie). La board du milieu permet de relier le moteur à l’Arduino. La board tout en haut permet de fournir de l’éléctricité à tous les composants.

miniCircuit complet

Et voilà ce que ça donne avec tout les câbles branchés ! Peut-être que j'aurais dû choisir un code couleur, cela m'aurait empêcher de provoquer un court-circuit (par deux fois !) ^^"

Changement de modèle – Jour 3

 

Deux moteurs IDENTIQUES sont nécessaires afin que le robot soit calibré et avance de la même façon vers la droite et vers la gauche.

Malheureusement, je ne possède pas deux moteurs identiques… Du coup, je vais plutôt utiliser un moteur pour la traction avant et un servo pour permettre le changement de direction.

Le principe :

Avec cette disposition, on veut que le servo tourne en fonction de l’input reçu. Si la LDR de droite reçoit de la lumière, le servo va tourner de 90° vers 180°. Si c’est la LDR de gauche, alors le servo va tourner de 90° vers 0°.

Le moteur (stepper motor) quand à lui devra se mettre à fonctionner peu importe la provenance de l’input (LDR de droite ou de gauche = idem).

Le code :

Pour le code, il suffit de mélanger deux codes déjà existants dans la bibliothèque Arduino : Le Sweep que l’on trouve dans la section Servo et AnalogInOutSerial que l’on trouve dans la section Analog.

On obtient ainsi un code du genre :

/* Code pour Robolight avec stepper motor et servo
 * Stepper motor relié au digital pin 9
 * Servo relié au digital pin 10
 * 2 LDR sont utilisées comme résistances variables dans un pont diviseur de tension.
 – Elles sont reliées aux pins A0 et A1
   L’objectif est de faire fonctionner le stepper motor peu importe quel pin analog (0 ou 1) franchit le seuil
   En revanche, il faut que lorientation du servo dépende du pin qui franchit le seuil.

Created 06 Jan. 2016
by Nikola Zarevski
*/
#include <Servo.h>

Servo theServo; // objet servo est créé
int pos = 90;   // Position initiale à 90°

const int analogInPin1 = A0; // input de LDR 1
const int analogInPin2 = A1; // input de LDR 2
const int analogOutPinStepper = 9; // Le moteur est relié au pin 9

int sensorValue1 = 0; // Valeur obtenue par LDR 1
int sensorValue2 = 0; // Valeur obtenue par LDR 2
int outputValueStepper = 0; // Valeur fournie pour le stepper motor

void setup() {
  Serial.begin(9600); //initialisation de la communication en série à 9600 bps (bits per second)  
  theServo.attach(10); // Le sevo est relié au pin 10
}

void loop() {
  // Pour les commandes, on veut que le servo agisse en premier et ensuite le motor afin que le robot puisse tourner
  sensorValue1 = analogRead(analogInPin1);
  sensorValue2 = analogRead(analogInPin2);
  if (sensorValue1 > 960)  // le seuil à franchir est à déterminer en fonction de la luminosité de la pièce et de la source lumineuse
  {
    for(pos = 90; pos > 0; pos -= 1)
    {
      theServo.write(pos);

   delay(15);
    }
    outputValueStepper = 255;
  }
  else if (sensorValue2 > 960)
  {
    for (pos = 90; pos < 180; pos += 1)
    {
      theServo.write(pos);
      delay(15);
    }
    outputValueStepper = 255;
  }
  else
  {
    outputValueStepper = 0;
  }
  analogWrite(analogOutPinStepper, outputValueStepper);
  delay(2000);
  pos = 90;
  theServo.write(pos);

 // Pour afficher les résultats sur le moniteur:
  Serial.print(“sensor1 = ” );                       
  Serial.print(sensorValue1);
  Serial.print(” \t sensor2 = ” );
  Serial.print(sensorValue2);
  Serial.print(” \t output = “);      
  Serial.println(outputValueStepper);   

  delay(15); //Attendre 15 ms avant de recommencer
}


Vous pourrez constater que je suis repassé à un output digital et non analogique car pour quelques raisons obscures le moteur refusait de fonctionner malgré un output correct. (Si vous savez quoique ce soit sur le sujet, n’hésitez pas à m’éclairer, je vous serais d’une reconnaissance éterneeeeelle)

Voilà, on a réussi à se débrouiller sans ce fichu second moteur.

Let’s do some soldering !

Le code sur Arduino – Jour 2

Il existe déjà un code dans la base de données d’Arduino IDE qui permet de faire fonctionner le moteur.

Aller dans Fichier -> Exemples -> Analog et cliquer sur AnalogInOutSerial.

La commande intéressante dans ce code, sur laquelle j'ai intervenu est :                                                 OutputValue = map(sensorValue, 0, 1023, 0, 255);

Le moteur fonctionnait à l’envers ( lorsque l’intensité lumineuse baissait, il se mettait à tourner ). Pour régler le problème, j’ai inversé les valeurs de map comme ceci :   OutputValue = map(sensorValue, 1023, 0, 0, 255);                    Ce qui a réglé le problème  mais quelques essais plus tard, le moteur s’est remis à fonctionner à l’envers… Le problème n’était donc que passager.

Une autre source de soucis était le fait que le moteur fonctionnait également pour des valeurs négatives de OutputValue. Donc le moteur fonctionnait dès lors que la luminosité variait et non pas uniquement lorsque la luminosité augmente. De plus, la photorésistance avait une grande sensibilité aux variations, le moteur se mettait à fonctionner lorsque je bougeais mes bras... (infime modification de la luminosité).

Après 3h de galère à essayer de manipuler la commande map pour réduire la sensibilité de la LDR mais tout de même obtenir un moteur qui tourne suffisament, j’ai décidé d’abandonner map… ^^’

Si vous êtes plus courageux et plus expérimenté que moi, un petit commentaire ? Pour expliquer comment on aurait pu s’y prendre ?  Sinon, j'ai opté pour une bonne vieille boucle if.

Au début, j’ai choisi de perdre l’aspect analogique et de passer à un mode digital :

void loop() {
  // read the analog in value:
  sensorValue = analogRead(analogInPin);
  if  (sensorValue > 980)  // valeur déterminée grâce au moniteur série (dans la barre outils)
  {
    outputValue = 255;   //valeur déterminée grâce au moniteur série
  }
  else
  {
   outputValue = 0;
  }
  analogWrite(analogOutPin, outputValue);

 

Mais finalement, avec l’idée de Gaspard (qui était de passage), je suis revenu sur un modèle analogique en déterminant outputValue en fonction de sensorValue :

outputValue = sensorValue / 4;

 

Il ne reste plus qu’à rajouter une entrée sur un analog pin (A1 par exemple) et une sortie sur un digital pin PWM pour le moteur et le tour est joué.

Le code étant terminé et opérationnel, il ne me reste plus qu’à construire le petit robot !

 

 

 

Les débuts – Jour 1

Liste de matériels :

Bonjour à tous, pour construire ce petit robot, je vais avoir besoin de :

  • Un Arduino UNO
  • 2 photorésistances
  • 4 résistances
  • 2 transistors
  • 2 diodes
  • 2 moteurs
  • 3 roues
  • Un support (plateforme pour le robot)
  • Des connecteurs

Le principe:

    Les photorésistances (ou LDR) possèdent une résistance variable en fonction de l’intensité lumineuse à laquelle elles sont exposées. Plus l’intensité de la lumière diminue, plus la résistance augmente. Il faut maintenant que la carte Arduino reçoit l’information de la variation de la résistance (variation de l’intensité lumineuse),  mais elle ne peut recevoir cette information directement. Il faut transformer la variation de la résistance en variation de tension grâce à un pont diviseur de tension. (Cliquez ici pour explications)

Pont_diviseur_de_tension_schema

On voit que la tension de sortie U2 vers l’Analog pin de l’Arduino dépend des résistances du montage.

J'ai choisi R1 = R2 avec R2 la valeur de résistance de la LDR à lumière ambiante (que l’on aura déterminée grâce à un multimètre) afin que la tension de sortie soit égale à la moitié de la tension de 5V fournie par l’Arduino.

minimultimetre_LDR

Les valeurs que j’ai obtenu pour les deux LDR sont : R1 = 7,9kΩ et R2 = 8,3 kΩ.

Pour construire mon pont diviseur de tension, j’ai donc besoin d’une résistance R1 de 8kΩ (10kΩ feront l’affaire).

miniPont_diviseur_build

    Maintenant que l'Arduino est devenu “sensible” à la lumière, il faut qu’il puisse envoyer l’information de mise en route des moteurs lorsque l’intensité lumineuse augmente. Mais comme les pins digitaux (PWM) de l’Arduino ne peuvent pas envoyer suffisament d’intensité pour mettre un moteur en marche, j’ai utilisé un transistor comme switch électronique.

Voici un lien expliquant le fonctionnement du switch électronique.

Donc je vais utiliser un transistor P2N2222A attaché à une résistance de 330Ω, une diode quelconque et un moteur que j’ai récupéré dans une ancienne imprimante.

minicircuit_complet

Voilà, le circuit est terminé pour un moteur est terminé ! Mais comme on veut un robot qui puisse tourner dans les deux sens, il me faut deux circuits identiques.

Maintenant, on va pouvoir passer au code ^.^


 

 

 

 

Pont diviseur de tension avec formule pour la tension de sortie