Robot capable de dÃ©tecter et d`afficher des obstacles

Transcription

Robot capable de détecter et d'afficher
des obstacles
Adel Kherchache Terminale S 3
Guillaume Gobin Terminale S 3
Sylvain Moretti Terminale S 3
Isnarduino.fr - Page 1
SOMMAIRE
Présentation..................................................................................................................................Page 3
Environnement de travail.............................................................................................................Page 5
Répartition des taches et collaboration........................................................................................Page 6
Partie personnelle
Partie personnelle d'Adel........................................................................................................Page 8-10
Partie personnelle de Sylvain...............................................................................................Page 11-13
Partie personnelle de Guillaume...........................................................................................Page14- 18
Annexe...................................................................................................................................Page20-41
PRESENTATION
Le projet s'est déroulé en 2 parties, la partie virtuel effectué sur l'IDE processing, et
la partie électronique que nous avons réalisé avec l'hardware arduino.
Dans un premier temps la problématique de notre projet était de développer un
programme qui gérera les déplacements d'un robot virtuel, dans notre programme le robot
sera modélisé par un carré. Ce dernier devra cartographier une pièce dans laquelle il aura
était placé. Pour cette partie nous nous sommes débrouillé seul avec quasiment aucune
aide extérieure au groupe.
Ensuite nous sommes passé à la partie "physique" du projet, pour cela nous avons
utilisé le software et l'hardware arduino, qui nous ont permis de réaliser notre projet avec
le peu de connaissances que nous avions. Pour cette partie nous avons fait beaucoup de
recherches sur internet, nous nous sommes en fin de compte orienté sur youtube qui nous
offrez le plus de solutions et surtout des images sur lesquelles nous pouvions nous
appuyer.
La première étape que nous avons effectué fut la création de l'environnement, 2D
dans notre cas. L'ordinateur devait simplement représenter une pièce dans laquelle nous
placerions notre robot afin qu'il la scan. Pour cela nous avons utilisé une "matrice", un
tableau à double entrée, qui formait un ensemble de cases qui elle-mêmes formaient la
pièce. Au début une case valant 1 représentait un obstacle et une case valant 0
représentait une case vide. Ensuite vint la création du robot, au début une simple
méthode, elle évolua en une "class", donc un objet. La robot créé nous passâmes à la
création de l'intelligence artificielle, il fallait ici coder chaque réponse possible pour toutes
les situations dans lesquelles le robot pouvait se trouver et ainsi qu'il ne soit jamais bloqué
ou bugué. C'est sur cette partie que nous avons passé le plus de temps. Une fois la base
du programme créée nous nous sommes attelés aux obstacles, d'abord fixes, nous les
avons amélioré pour qu'à chaque lancement du programme ils soient différents. Enfin la
dernière partie, la création de la seconde fenêtre et des options. Cette partie a été réalisée
en langage JAVA non-simplifié, donc dans le langage que pouvait utiliser un développeur.
Pour le projet nous devions créer un site, les autres groupes ayant choisis de créer
le leur sur des sites déjà pré-fabriqué tel que webnode.fr, nous avons choisi, et c'est
important de le souligner vu le temps que cela nous a pris, de développer le notre de A à Z
en HTML/CSS/JAVASCRIPT.
A partir de là, le premier objectif était rempli : la partie virtuelle. Il nous a maintenant
fallu réaliser la partie arduino.
Malgré ce que l'on peut penser, et cela grâce à la simplicité d'utilisation de l'arduino,
ce fut la plus simple et la plus rapide des tâches que nous ayons accompli. Le plus long a
été d'attendre le matériel que nous avions préalablement commandé, une fois reçu nous
avons finis le robot en seulement 2 séances de groupe. Nous avions la voiture et tout le
matériel pour construire une vraie voiture autonome.
Nous avons donc enlevé tout ce qui ne nous servait pas, la coque, les piles... Puis
nous avons installé le module arduino à la place de l'ancienne carte électronique, ne
restait plus qu'à brancher le moteur et le servo-moteur au Motorshield, qui se trouvait sur
l'arduino et à développer un simple code, avec le software d'arduino, pour que la voiture
avance et recule.
Nous avons ensuite amélioré le tout en rajoutant un interrupteur, que nous avons
nous-même créé, ainsi notre voiture était entièrement autonome... ou presque ! A ce jour
elle fonctionne, mais uniquement quand elle se trouve branchée à l'ordinateur par le câble
USB, elle ne fonctionne pas avec une alimentation par pile 9V.
( POUR LES CODES VOIR ANNEXES )
ENVIRONNEMENT DE TRAVAIL
Pour notre projet nous avons donc utilisé en premier lieu l'IDE open-source
processing. (processing.org)
Ensuite nous avons utilisé le software et hardware arduino ( arduino.cc ) deux
environnement de travail très bien adapté pour des élèves de Terminales voulant s'initier
au monde passionnant de l'informatique, et l'un de leur principaux avantages est qu'ils
sont gratuits et open-source.
Pour le partage en ligne, nous utilisé Google Drive :(google.com/intl/fr_fr/drive/)
Google Drive est aussi totalement gratuit et l'accès au partage est simple se qui favorise
l'échange entre camarades.
Enfin, pour le développement de notre site web nous avons utiliser Sublim eText, lui aussi
gratuit et vraiment intéressant. ( sublimetext.com)
Répartition des tâches
Tache
Mise au point des objectifs
Création de la carte
Création du robot
Création de l'intelligence
artificielle
Création d'obstacles
Création d'une seconde
fenêtre
Mise en commun et
finalisation
Début de la partie robotique :
réflexion
Achat du matériel
Démontage d'une voiture
Assemblage du robot
Planning
02/11/14
12/11/14
10/12/14
Nom
Adel/Guillaume/Sylvain
Adel/Guillaume
Adel
12/12/14
Guillaume
19/12/14
Guillaume/Sylvain
30/12/14
Sylvain
02/01/15
14/01/15
15/01/15
30/01/15
04/02/15
Sylvain/Guillaume
Au début, le groupe n’était formé que de Guillaume et d’Adel, puis Sylvain nous a
rejoint, étant fort intéressé par notre idée de voiture autoguidée. Nous sommes tous les
trois passionnés d’informatique et de robotique. La collaboration s’est donc naturellement
effectuée sous l’égide de l’amitié et de l’entente. Nous nous sommes tout de suite
entendus sur le fait de partager le travail. Guillaume a donc pris la partie algorithmique
(donc de l’intelligence artificielle) du programme, Adel s’est chargé du robot et de la carte
tandis que Sylvain s’est chargé de la seconde fenêtre et de tous ce qui lui était lié.
Pour cette collaboration nous avons utilisé la plate forme de partage en ligne la plus
pratique et la plus rependus : Google Drive. A chaque modification, ou ajouts, au projet,
une nouvelle sauvegarde était créé, avec le nom de l’élève et la date à laquelle la
modification à était effectuée.
Cette méthode nous a permis de suivre le rythme d’évolution du projet et ainsi de donner
un petit coup d’accélérateur que cela était nécessaire.
Enfin quand chacun pensait avoir finis sa partie, nous avons mis le tout en commun et
finaliser le projet, en y ajoutant quelques point ou en corrigeant d’autres.
Partie Personnelle Adel
Notre projet comporte deux grandes parties : celle concernant l'Arduino, avec le
robot, et celle concernant la partie Processing.
Pour cette dernière, nous étions dans l'obligation de créer un environnement dans
lequel le robot pouvait se mouvoir. Cet environnement allait donc contenir les différents
obstacles générés aléatoirement, ainsi que le robot.
Nous nous sommes donc demander comment il serait possible de créer un tel
environnement. Après maintes recherches, c'est seulement après une discussion avec un
ami que l'idée de matrice apparue. Guillaume et moi avons ainsi réfléchis sur son
utilisation...
Comment la créer ? Comment en faire un environnement utilisable facilement et
rapidement ?
Pour la créer nous avons penser à faire deux boucles for emboîté permettant de balayer, à
l’aide des variables i et j, tout le tableaux. Ceci nous a permis de rentrer des valeurs dans
le tableau, ces valeurs correspondant aux obstacles ou autres. A l’aide de la variable gC,
nous avons pu synchroniser le tableau avec l’affichage. En effet, la variable , était la valeur
de référence; on multiplier les coordonnées du robot x,y par gC, pour qu’il se déplace de
case en case, on divisait i et j pour donner respectivement u et v, pour que les
coordonnées des cases affichés à l’écran correspondent aux coordonnées dans le
tableau.
Une fois cela terminé, ma première partie personnelle du projet était de créer le
robot qui allait ensuite se déplacer, rien de bien compliqué, car Guillaume tenait à se
charger personnellement de la partie plus difficile : l'intelligence Artificielle.
L’objectif était donc de créer l’objet en lui-même. Ici, la programmation orienté objet
est donc nécessaire. C’est pour cela que j’ai créé l’objet “Robo”, qui prendrait comme
paramètres “rX”, soit la coordonnée en x, ainsi que “rY”, soit la coordonnée en y, sans
oublier le cosmétique avec le choix de la couleur grâce à la variable “couleur”.
J’ai eu un petit problème au début pour “synchroniser” le robot avec la matrice, mais après
plusieurs essais j’ai fini par résoudre le problème : il suffisait de multiplier la coordonnée
voulu par “gC” (soit la taille d’une case de matrice).
création de l’objet : Robot robot = new Robot(x*gC,y*gC,#EA1111); .
Le robot.
Une fois cela terminé, je commençais à développer le site web pendant que
Guillaume et Sylvain s’occupaient de la génération des obstacles et de la seconde fenêtre.
Pas grand chose en particulier à développer sur ce point, si ce n’est que je l’ai codé en
HTML/CSS, et que du javascript est également présent, par exemple sur la catégorie
“Code Source”.
J’avais prévu à la base de créer un mode édition pour pouvoir ajouter des pages au carnet
de bord plus simplement que de passer par le logiciel FileZilla, mais un problème s’est
posé quant à la mise en place de la fonction car je manque de connaissances en PHP et
base de données..
Il est possible de visualiser le cours du travail en se rendant sur la page d’accueil et en
cliquant sur “rentrer en mode édition”. Le mot de passe est simplement “edition”. On se
retrouve ensuite sur la page suivante avec un formulaire que l’on peut remplir.
Capture d’écran de la page d’édition.
Tout le développement de comment a été fait la partie machine (arduino) se trouve
sur la partie personnelle de Guillaume car nous ne voulions pas dupliquer trois fois la
même chose (schémas etc…).
Enfin , j’aurais aimé développer une application mobile qui soit liée avec le robot par
wifi ou Infrarouge (ou même par bluetooth), afin qu’elle montre ce que celui-ci est en train
de cartographier, néanmoins la partie machine a pris bien plus de temps que prévu. De
plus il se pose des problèmes sur le fonctionnement de l’application, car la mise en
situation réelle était plus complexe (car plus de paramètres à prendre en compte, comme
la taille de la salle, la position de départ du robot, la forme des obstacles qui ne sont pas
tous rectangles comme sur processing etc) que sur la partie logicielle processing.
Cette expérience fut très enrichissante personnellement, car c’est le premier projet
de groupe que je fais sur un sujet qui me tient particulièrement à coeur : l’informatique.
Cela m’a donc appris le travail d’équipe, le travail à long terme sur une même chose, etc..
De plus, j’ai appris beaucoup de choses en Processing, ce qui m’a donné envie de
commencer mon propre projet personnel : un jeu de rôle à l’époque médiéval
( http://klaes-fate.livehost.fr/ ).
Partie personnelle de Sylvain
Suite au partage des taches je devais m'occuper des obstacles, de la création d'une
seconde fenêtre et de tout le paramétrage du programme.
J'ai donc commencer pas la création d'une seconde fenêtre, dans JAVA, la class
responsable de la fenêtre est la classe JFrame, j'ai donc créer une classe « PFrame », qui
hérité des attributs de Jframe :
class PFrame extends Jframe
A cette classe j'ai ajouter ensuite quelques modifications, comme sa taille, son titre,
sa position au lancement du programme...
Je me suis ensuite atteler à la création des boutons, là encore les fonctions déjà
présente dans JAVA, qui ne nécessitent qu'un import, m'ont bien aidé puisque la encore je
me suis servis de l'hérédité, vraiment très pratique, qu'offre JAVA :
class Slide extends JSlider
Exemple de Slider :
Dans la classe Slider, j'ai ensuite modifier là encore quelques paramètres tel que sa
taille, son minimum, son maximum, les ticks ( entre les petits et les grand traits sur l'image
du dessus )...
J'y ai ensuite ajouter la méthode « StateChanged » :
void stateChanged(ChangeEvent event)
Cette méthode tourne en boucle et vérifie l'état du slider, si ce dernier change, si on
le met par exemple a 20, la méthode va immédiatement le savoir et ainsi exécute
l'instruction à la suite :
compteurAmpliMax=((JSlider)event.getSource()).getValue();compteurAmpli = 0;
Si on met le Slider a 20, compteurAmpliMax prend la valeur 20.
class Pan extends JPanel
Un JPanel est un conteneur qui se trouver a l’intérieur d'une fenêtre :
J'ai ensuite créer des boutons, encore une fois mon travail fut simplifié par les
fonctions intégrées dans JAVA :
final JRadioButton but1 = new JRadioButton("Cyan");
J'ai donc créer un nouvel objet de la class JRadioButton , le mot-clés « final »
signifie qu'il est non modifiable, le programme ne marche pas si il n'est pas présent.
A ces boutons on ajoute ensuite la fonction actionPerformed(ActionEvent e), qui a
un peu le meme principe de fontionnement que stateChanged(ChangeEvent event) :
void actionPerformed(ActionEvent e)
if(but1.isSelected() == true) {coul = #00F4FF;}
}});
Si on presse le bouton ( on clique dessus ), la variable « coul » est modifié.
Apres l'ajout des panels, slider et boutons il faut maintenant les ajouter à a la fenetre, avec
la méthode « add », qu'on applique à « this » qui est la fentre ici :
this.add(panGroup2);
Le panel « panGroup2 » est ajouter à la fenêtre.
Pour finir on rend notre fenêtre visible avec :
this.setVisible(true);
POUR LE CODE COMPLET, VOIR ANNEXE
Étant fortement intéresser par l'informatique, j'avais acheté et lu « Apprenez à
programmer en Java ( Livre du Zéro ) de Cyrille Herby, pendant les vacances de transition
entre la première et la terminale, c'est pour cela que j'ai utilisé des méthodes non vus en
cours tel que ActionListener(). C'est aussi grâce a cela que je n'ai pas eu de réelle
difficulté a développer cette partie, cela représente environ 5 ou 6 heures de travail.
Lors de la mise en commun du projet j'ai évidement expliquée tout cela a mes
collègues.
Ce que le travail m'a apporté c'est encore plus de passion pour l'informatique, des
connaissances en JAVA mais aussi à travailler en équipe et à faire confiance à mes
collègues, car nous avons construits une véritable entente, même si tout le monde ne
travaille et n'apporte pas autant au groupe, je pense que nous avons tout les trois appris
beaucoup de ce projet.
Partie personnelle de Guillaume:
Notre projet se constituait de deux parties : la partie arduino avec le robot et la
partie processing. Pour la partie processing, nous devions créer un environnement dans
lequel le robot pouvait se déplacer. Il fallait un environnement où des obstacles aléatoires
apparaissait et ou on pouvait faire la différence entre les obstacles et le vide
automatiquement et simplement. L’idée de faire une matrice m’est venu d’un ami pendant
une discussion. Ayant l’idée en tête, je l’ai partagé au reste de l’équipe. Adel et moi avons
réfléchis sur l’utilisation de la matrice. Comment la créer ? Comment en faire un
environnement ? Pour la créer nous avons penser à faire deux boucles for emboîtées
permettant de balayer, à l’aide des variables i et j, tout le tableaux. Ceci nous a permis de
rentrer des valeurs dans le tableau, ces valeurs correspondant aux obstacles ou autres. A
l’aide de la variable gC, nous avons pu synchroniser le tableau avec l’affichage. En effet,
la variable gC, était la valeur de référence; on multiplier les coordonnées du robot x,y par
gC, pour qu’il se déplace de case en case, on divisait i et j pour donner respectivement u
et v, pour que les coordonnées des cases affichées à l’écran correspondent aux
coordonnées dans le tableau. Une fois la matrice synchronisée je me suis tourné vers
l’algorithme du comportement du robot. La création de cet algorithme a été plutôt long. Au
début, je suis parti sur une idée simple. J’ai fais un comportement en cas par cas, c’est à
dire, que je définissais chaque situation dans laquelle le robot pouvait se trouver, et j’y
assignais une réponse. Ces situations correspondait à l’emplacement des obstacles par
rapport au robot et sa direction. Et les réponses était qu’il aille soit vers sa gauche, soit
vers sa droite, ou faire demi-tour. Ce premier algorithme effectué, je le partageais avec
mes associés. L'algorithme présentait de gros défauts. En effet, malgré la réaction pour
chaque cas, le robot n’avait aucune diversité dans son déplacement et les répétés sans
cesse, il ne pouvait pas cartographier l’environnement comme ceci. Pour remédier à ce
problème j’ai essayé de penser un tout autre algorithme, en oubliant le précédent. Le
nouveau algorithme était un algorithme scripté. En effet, je donnais au départ une direction
au robot, et suivant ça direction, lorsqu’il rencontrait un obstacle, il montait d’une ou deux
cases, et revenait en arrière. Il dessinait ainsi des zig-zag, faisant des allez et retour
décalés. Les “zig-zag” changaient de sens quand il ne pouvait plus descendre ou monter,
il faisait donc des “zig-zag” verticaux, et ainsi de suite. Cet algorithme était prometteur.
Nous n’avions pas encore fait les obstacles, et sans ceux là, l’algorithme était parfait, il
cartographiait l’intégralité de la pièce.
Ensuite, nous nous sommes donc penché sur les obstacles avec sylvain. Tout
d’abord, j’ai cherché de mon côté. J’avais recréé une méthode rect() mais dans la matrice.
C’est à dire qu’avec cette méthode, ceci pouvait me créer un rectangle d’obstacle dans
l’environnement 2D. J’ai donc ensuite créé un par un les obstacles, leur mettant des
coordonnées et des dimensions aléatoires avec int(random());. Ensuite, Sylvain a eu l’idée
de faire de l’obstacle un objet, et de se servir d’une boucle pour les générer au lieu de les
faire un par un. Nous nous mettions au travail cherchant à faire cela. En s’inspirant de la
méthode préalablement créé, nous faisions l’objet obstacle, et ensuite, avec une boucle
for, tournant jusqu’à un nombre aléatoire, qui correspondait au nombre d’obstacles
générés, nous mettions la création de l’objet, avec des coordonnées et des dimensions
aléatoires, et nous l’appelions tout de suite après. Les obstacles s’affichaient très bien.
Nous avons connu un petit soucis pendant une génération: un obstacle c’était généré sur
l’emplacement d’apparition du robot, le robot était donc coincé. Pour ça, sylvain et moi
avons reprit la fonction rect() créé spécialement pour la matrice, et nous avons inversé les
valeurs de génération. C’est à dire qu’au lieu de créer un rectangle d’obstacle, nous avons
créé un rectangle de vide, sur l’emplacement du robot. Ainsi, il n’y avait plus de soucis. A
ce moment là, le projet était comme finit. Sauf que l’algorithme du robot ne fonctionnait
plus comme il devait. Il présentait des imperfections, où il lui arrivait de traverser les
obstacles ou même quand il ne le faisait pas, il ne cartographier pas l’intégralité de la
carte. En effet, il faisait son chemin scripté de “zig-zag”, mais 90% des générations faites,
il revenait sur ses pas, et ne cartographier plus rien de nouveau. J’ai donc essayé de
trouver une solution; celle ci était était de dire au robot lorsqu’il restait sur une zone déjà
vérifié pendant trop de temps, autrement dit, s’il restait sur ses pas, qu’il devait prendre
une nouvelle direction aléatoire. J’avais résout ce problème, mais cependant l’algorithme
présentait toujours cette imperfection de traverser les murs une génération sur dix environ.
Cet algorithme que j’avais fais était plutôt complexe, des booleans et tout autres
conditions était en jeu, tout était équilibré pour fonctionnait, je ne voyais pas d’où venait le
problème. J’essayais de modifier des lignes, mais ça déséquilibrer tout le reste, et
l’algorithme ne fonctionnait plus. Jusqu’au moment ou j’avais compris d’où venait le
problème. C’était que pendant un cas précis, un type de boolean, s’activer, et ne se
désactiver plus, faisant tout buguer. Réfléchissant, la solution était de faire encore plus
d’instructions et de conditions, pour faire des réponses pour d’autres cas, et donc
d’agrandir l’algorithme. Sauf, qu’à la base, j’avais créé cet algorithme pour être moins
long, plus compact, plus efficace. Il ne l’était donc pas, peut-être plus compact, plus
efficace, mais imparfait. J’étais dans une impasse. Je me suis donc retourné vers mon
ancien algorithme, qui était parfait mais qui malheureusement ne donnait aucune diversité
de déplacement au robot. J’ai donc eu l’idée de faire un second algorithme lié à ce dernier
pour donner de la diversification au déplacement. L’idée était de mettre un compteur qui
incrémentait de 1 à chaque tour du draw() et que s’il arrivait à une valeur tM il prenait une
direction aléatoire. Ainsi, l’algorithme était parfait, et ayant un mouvement diversifié. Par la
suite, j’ai implanté mon nouvel algorithme au programme original, sylvain avait mit son
onglet “paramétrage”, et notre programme semblait finit. Tout les trois, nous avons repris
le programme de A à Z. Nous avons corrigé des imperfections, amélioré des lignes de
codes, mit des commentaires, et changé le nom de quelques variables et de méthode
pour qu’elles soient plus explicite, nous avons aussi rajouté des options dans l’onglet
paramétrage. Nous avons finalisé le programme. Après ça, pour s’assurer de la perfection
du programme, nous avons fait une série de test : nous avons allumé le programme de
nombreuses fois pour voir s’il y avait des problèmes de génération d’obstacle, nous avons
attendu que le robot cartographie l’intégralité de la pièce pour voir s’il y avait un problème
dans l’algorithme, nous avons même chronométré le temps que prenait le robot à tout
cartographier, et pour chaque génération, le robot a cartographiait l’intégralité de
l’environnement en environ 5 min. Ce qui était plutôt satisfaisant.
Après le programme finit, nous nous sommes lancé dans la partie Arduino. Sylvain
a ramené une voiture qu’il avait chez lui, nous l’avons démonté, enlevé ce qui était inutile,
gardant le moteur, servo moteur, les roues et le châssis. Quand nous avions tout les
composants, nous avons attendu longtemps avant d’avoir le motor shield. Le motor shield
nous permettait de protéger la carte Arduino UNO. En effet, si on branchait les moteurs
directement à la carte Arduino ceux ci pouvaient l’endommager. Nous avons donc placé le
motor shield au dessus de l’arduino et avons branché le moteur et le servo moteur. Avec
un programme très simple à coder, nous avons tout d’abord fait avancé le robot. Puis nous
l’avons fait, avancer et reculer et ensuite nous l’avons fait zigzaguer, tout en avançant ou
en reculant. Pour finir, nous avons construit un interrupteur avec des matériaux
préalablement acheté pour pouvoir faire un capteur de chocs. Pour faire cet interrupteur
nous avons acheté 1 barre d’aluminium d’un mètre, des ressorts très petits et fins, du
ruban adhésif et de la glu. Nous avons découpé la barre d’1 mètre, pour avoir deux barres
de 20 centimètre, nous avons tordu une barre des deux cotés pour pouvoir y fixer les
ressorts. Et nous avons collé les ressort avec de la glu, pour les isoler. Nous avons
ensuite mis du ruban adhésif pour que les barre d’aluminium soit droite, et aussi pour faire
tenir les fils de cuivre relié au deux cotés de l’interrupteur. Voir Schéma ci-dessous:
Schéma des branchement de la voiture autoguidé
La voiture ayant un programme qui répond en cas d’obstacle détecté par le capteur en
faisant un demi-tour fonctionne presque parfaitement. En effet, il y a deux problèmes
majeurs, malgré le fait que théoriquement notre voiture fonctionne. Le premier problème
est que la voiture est très lente avec le branchement USB. Elle avance et recule, elle
tourne à droite et à gauche, mais parfois elle s’arrête car le moteur n’est plus assez
puissant. L’idée pour résoudre ce problème serait de changer de moteur et d’engrenage
pour les roues arrières. Le deuxième problème est l’autonomie de la voiture. En effet, la
voiture fonctionne que quand elle est branché par l’USB de l'ordinateur. Lorsqu’on
alimente la carte Arduino avec une alimentation extérieur de 9V, par la prise jack, la
voiture ne marche plus, la carte Arduino s’allume, les diodes clignotent, mais les moteurs
ne tournent pas et restent inactif. Au départ, je pensais qu’une pile 9V n’était pas assez
puissante. Je me suis renseigné et j’ai découvert qu’un port USB fournissait du 5V. Le
problème ne venait sans doute pas de là. Nous avons cherché sur internet… Aucune
recherche ne nous aidez. A ce jour, nous n’avons pas réglé ces deux problèmes.
Pour finir, j’aurais souhaité régler ces deux problèmes par rapport à Arduino et en plus
améliorer l’utilité de cette voiture. En effet, à la base notre projet était de faire en sorte que
la voiture enregistre l’emplacement des obstacles détecté qu’elle aura frappé et donc
qu’elle cartographie la pièce. De plus, nous avions pour idée de relier la voiture à une
application Smartphone pour voir le robot cartographier la pièce sur l’application en direct.
Mais la finalisation de ce projet semblait être hors de portée pour des débutants élève en
Terminale. J’espère prendre ma revanche une fois en IUT…
ONGLET 1
//Importation des bibliotheques java.
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JLabel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JSlider;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.Dimension;
import javax.swing.ButtonGroup;
import javax.swing.JRadioButton;
//--- DEBUT VARIABLES ---
//ENTIERS :
//Des entiers nommés sX et sY sont créé avec les valeurs 800 et 600. (taille de la matrice et de la
fenêtre)
int sX = 800, sY = 600;
//gC = grandeurCases (c'est ce qui définit la grandeur des cases en pixels). Cette variable sert de
référence pour synchroniser l'affichage des cases aux coordonnées de la matrice
int gC = 10;
//Coordonnées du robot
int x = (sX/2)/gC, y = (sY/2)/gC; //Le robot apparaît au milieux avec ces coordonnées
//Coordonnées du robot dans l'objet
int rX;
//rX et rY évolue en fonction de x et y.
int rY;
//Vitesse du Robot
int V = 1;
//Variables de déplacement du robot qui évolue en fonction de V.
int dx = V, dy;
//valeur des frameRate
int v = 50;
//ce compteur prends plus un à chaque tour du draw
int compteurAmpli = 0;
//Si le compteur arrive à cette valeur alors le robot tourne aléatoirement
int compteurAmpliMax = 8;
//TABLEAU D'ENTIER:
//Un tableau à double entrées d'entiers nommés ma est créé avec pour taille sX et sY
int [][]ma = new int[sX][sY];
//OBJET :
//Création de l'objet robot
Robot robot = new Robot(x*gC,y*gC,#EA1111);
//BOOLEANS :
//boolean pour afficher ou cacher les obstacles
boolean affObs = false;
//affichage du quadrillage
boolean affNoStroke = false;
//Boolean pour activer ou désactiver l'amplitude de mouvement.
(s'il elle est désactivé le robot ne tourne plus aléatoirement et continu tout droit jusqu'à arriver
contre un obstacle)
boolean desactAmpliAuto = true;
//COULEUR :
//Couleur du robot
color coul;
//--- FIN VARIABLES ---
//=== SETUP ===
void setup(){
//Création d'une fénêtre. Avec les dimensions sX et sY.
size(sX,sY);
//Ces méthodes sont appelés qu'une fois, car les créations qu'elles apportent pourront être modifiés
dans le draw
//Appel de la méthode setMat() qui va créer un environnement 2D vierge
setMat();
//Appel de la méthode genObstacles() qui va créer un nombre obstacles aléatoires ayant des
coordonnées et des dimensions aléatoires.
genObstacles();
//Appel de la méthode secureSpawn() qui va balayer la zone d'apparition du robot pour qu'il
n'apparaisse dans aucun obstacles.
secureSpawn();
}
//=== FIN SETUP ===
//=== LOOP ===
void draw(){
//Les ips (image par seconde) du programme prennent la valeur v.
frameRate(v);
//Appel de la méthode genMat() qui va donner la couleur des cases suivant leur valeur. De plus, elle
réinitialise la valeur des murs pour qu'ils soient toujours égale à 3.
genMat();
//Appel de la méthode affNoStroke() qui va décider, suivant le boolean affNoStroke, si on affiche
ou pas le quadrillage.
affNoStroke();
//Appel de la méthode cadre() qui va créer des rectangles pour former un cadre.
cadre();
//Appel de robot.display() qui va créer le robot, avec ses coordonnées, et la valeur de son
déplacement. De plus, la méthode dComportementRobot() y est intégré.
//La méthode dComportementRobot() est la méthode qui donne le comportement du robot face à un
obstacle. De plus, cette méthode à la méthode mAmpli() d'intégré qui sert à faire tourner le robot
aléatoirement, même quand il n'y a pas d'obstacles, à chaque intervalle de temps. Ceci dans le but
de varier son déplacement.
robot.display();
//Appel de la méthode mAffObs() qui va décider, suivant affObs, si on affiche ou pas les obstacles.
mAffObs();
//si le compteurAmpli est égale à 51 alors le robot ne tourne plus aléatoirement (desacAmpliAuto
se désactive)
if(compteurAmpliMax == 51){desactAmpliAuto = false;}else{desactAmpliAuto = true;}
}
//=== FIN LOOP ==
ONGLET 2
//Méthode servant à faire le comportement du Robot
void dcomportementRobot(){
if(desactAmpliAuto == true){ //Si l'amplitude auto est désactivé alors mAmpli n'est pas appelé
mAmpli();}
//(OBSTACLE A DROITE)
//Si le robot à un déplacement vers la droite ET que la case qu'il y a à droite est un obstacles caché,
affiché ou détecté alors cette case prends la valeur 4 (obstacles détectés).
if(dx == V && ma[x+V][y] >= 2){ ma[x+V][y] = 4;
if (ma[x][y-V] > 1 && ma[x][y+V] <= 1) }
//De plus s'il y a un obstacle en haut et rien en bas alors...
int w = int(random(2));
//un entier prends une valeur aléatoire entre 0 et 1.
if (w == 0) {
//s'il est égale à 0 alors le robot va vers le bas
dy = V ;
dx=0;
} else {
//sinon il fait demi tour.
dx = -V ;
}
}
if (ma[x][y-V] <= 1 && ma[x][y+V] > 1) {
//De plus s'il y a un obstacle en bas et rien en haut alors...
if (w == 0) {
//s'il est égale à 0 alors le robot va vers le haut
dy = -V ;
dx=0;
} else {
//sinon il fait demi tour.
dx = -V ;
}
}
if (ma[x][y-V] <= 1 && ma[x][y+V] <= 1) {
//De plus s'il n'y a un obstacle n'y en haut, n'y en bas alors...
dx = 0;
//(le déplacement en x prends 0 car il ira soit vers le haut soit vers le bas)
if (w == 0) {
//si cet entier est égale à 0 le robot va vers le haut
dy = -V ;
} else {
//sinon il va vers le bas
dy = V ;
}
}
if (ma[x][y-V] > 1 && ma[x][y+V] > 1) {
//De plus s'il y a des obstacles en haut et en bas
dy = 0;
//alors il fait demi tour.
dx = -V ;
}
}
//(OBSTACLE A GAUCHE)
//Si le robot à un déplacement vers la gauche ET que la case qu'il y a à gauche est un obstacles
caché, affiché ou détecté alors cette case prends la valeur 4 (obstacles détectés).
if(dx == -V && ma[x-V][y] >=2 ){ ma[x-V][y] = 4;
if (ma[x][y-V] > 1 && ma[x][y+V] <= 1) {
//S'il y a un obstacle en bas et pas en haut alors il peut soit faire demi tour soit aller vers le bas.
if (w == 0) {
dy = V ;
dx=0;
} else {
dx = V ;
}
}
if (ma[x][y-V] <= 1 && ma[x][y+V] > 1) {
//S'il y a un obstacle en haut et pas en bas alors il peut soit faire demi tour soit aller vers le haut.
if (w == 0) {
dy = -V ;
dx=0;
} else {
dx = V ;
}
}
if (ma[x][y-V] <= 1 && ma[x][y+V] <= 1) {
//S'il n'y a pas d'obstacle ni en haut, ni en bas, alors il va soit en haut, soit en bas
dx = 0;
if (w == 0) {
dy = -V ;
} else {
dy = V ;
}
}
if (ma[x][y-V] > 1 && ma[x][y+V] > 1) {
//S'il y a des obstacles en haut et en bas, alors il fait demi tour
dy = 0;
dx = V ;
}
}
//(OBSTACLE EN BAS)
if(dy == V && ma[x][y+V] >= 2){ma[x][y+V] = 4;
if (ma[x+V][y] > 1 && ma[x-V][y] <= 1) {
//Obstacle à droite et pas à gauche alors il va soit à gauche soit il fait demi-tour
if (w == 0) {
dx = -V ;
dy=0;
} else {
dy = -V ;
}
}
if (ma[x+V][y] <= 1 && ma[x-V][y] > 1) {
//Obstacle à gauche et pas à droite alors il va soit à droite soit il fait demi-tour
if (w == 0) {
dx = V ;
dy=0;
} else {
dy = -V ;
}
}
if (ma[x+V][y] <= 1 && ma[x-V][y] <= 1) {
//Obstacle ni à gauche, ni à droite alors il va soit à gauche soit à droite
dy = 0;
if (w == 0) {
dx = -V ;
} else {
dx = V ;
}
}
if (ma[x+V][y] > 1 && ma[x-V][y] > 1) {
//Obstacle à droite et à gauche alors il fait demi-tour
dy = -V;
dx = 0; } }
//(OBSTACLE EN HAUT)
if(dy == -V && ma[x][y-V] >= 2){ ma[x][y-V] = 4;
if (ma[x+V][y] > 1 && ma[x-V][y] <= 1) {
//Obstacle à droite et pas à gauche alors il va soit à gauche soit il fait demi-tour
if (w == 0) {
dx = -V ;
dy=0;
} else {
dy =V ;
}
}
if (ma[x+V][y] <= 1 && ma[x-V][y] > 1) {
//Obstacle à gauche et pas à droite alors il va soit à droite soit il fait demi-tour
if (w == 0) {
dx = V ;
dy=0;
} else {
dy = V ;
}
}
if (ma[x+V][y] <= 1 && ma[x-V][y] <= 1) {
//Obstacle ni à gauche, ni à droite alors il va soit à gauche soit à droite
dy = 0;
if (w == 0) {
dx = -V ;
} else {
dx = V;
}
}
if (ma[x+V][y] > 1 && ma[x-V][y] > 1) {
//Obstacle à droite et à gauche alors il fait demi-tour
dy = V ;
dx = 0;
}
}
}
//Méthode servant à faire tourner le robot aléatoirement en fonction de son déplacement actuel(s'il
se déplace vers la droite, vers le haut etc.)
void mAmpli() {
if ( compteurAmpli == compteurAmpliMax) {
//Si le compteur est égale à la limite alors il va prendre une direction aléatoire :
if (dx == V ) {
//S'il va vers la droite
if (w == 0) {
//un entier prends une valeur aléatoire entre 0 et 1
//si cet entier est égale à 0 le robot va vers le haut
dy = V ;
dx=0;
} else {
//sinon il va vers le bas
dy = -V ;
dx=0;
}
}
else if (dx == -V ) {
//S'il va vers la gauche il peut soit aller vers le haut, soit aller vers le bas
if (w == 0) {
dy = V ;
dx=0;
} else {
dy = -V ;
dx=0;
}
}
else if (dy == V ) {
//S'il descends il pourra aller soit à gauche, soit à droite
if (w == 0) {
dx = V ;
dy=0;
} else {
dx = -V ;
}
dy=0;
}
else if (dy == -V ) {
//S'il monte il pourra aller soit à gauche, soit à droite
if (w == 0) {
dx = V ;
dy=0;
} else {
dx = -V ;
dy=0;
}
}
compteurAmpli = 0;
//Le compteur reprend la valeur 0
}
compteurAmpli++; }
//Le compteur prends plus 1
ONGLET 3
/*Si ma[u][v] = ...
0 = vide
1 = vérifié
2 = obstacle caché
3 = obstacle affiché
4 = obstacle détecté
*/
//On balaye tout le tableau avec les deux boucles for pour assigner à toutes les case la valeur 0
(vide).
void setMat(){
for(int i = 0; i < sX; i+=gC){
for(int j = 0; j < sY; j+=gC){
int u = i/gC;
//Diviser i et j par gC revient à créer des coordonnées qui reviennent
int v = j/gC;
//à compter les cases qu'on voit à l'écran.
ma[u][v] = 0;
}
}
}
//Cette méthode sert à balayer toutes les coordonnées du tableau pour afficher les cases avec leurs
couleurs.
void genMat(){
int u = i/gC;
int v = j/gC;
//Ces instructions créaient un cadre:
ma[u][0] = 3;
//Toutes les cases ayant pour coordonnées [u;0] prennent la valeur 3
ma[0][v] = 3;
//Pareil mais avec [0;v]
ma[(sX-1)/gC][v] = 3;
//Pareil avec [sX-1/gC;v] c'est à dire la dernière valeur sur l'axe
des abscisses.
ma[u][(sY-1)/gC] = 3;
//Idem mais avec la dernière valeur sur l'axe des ordonnées
//Ces instructions servent à donner les couleurs respectives aux rectangles (case) :
if(ma[u][v] == 3 || ma[u][v] == 4){fill(0);}
else if(ma[u][v] == 1){fill(#96DBFC);}
else{fill(255);}
rect(i,j,gC,gC);
}
}
}
/*
Le setMat est appelé dans le setup, il s'éxécute donc une fois. Ceci dans le but de faire un
environnement vide qui pourra être modifié.
En effet, le genMat est appelé dans le draw, il s'éxécute indéfiniment. Le but est d'afficher et de
"mémoriser" les modifications
apporté à l'environnement. ( quand le robot tape contre un obstacle il s'affiche en noir ou le robot
laisse une trainée bleue derrière lui.
*/
//Ceci est la class Robot pour créer le Robot:
class Robot {
Robot(int RX, int RY, color couleur){ //constructeur de l'objet, on lui assigne des coordonnées et
une couleur.
rX = RX;
rY = RY;
coul = couleur;
}
void display(){
dcomportementRobot();
x += dx;
// on ajoute à x ou à y la valeur du déplacement
y += dy;
// dx ou dy qui peut être égale à V,-V ou 0
ma[x][y] = 1;
// Toutes les coordonnées que le robot aura empreinté auront la valeur 1. (case vérifié)
fill(coul);
//Assigne la couleur au robot (rectangle)
rect(x*gC,y*gC,gC,gC);
//Création d'un rectangle aux coordonnées x*gC et y*gC. (comme V est égale à 1, le robot doit
multiplier ses coordonnées pour qu'il soit affiché correctement à l'emplacement voulu)
}
}
//Cette methode sert à balayer la zone d'apparition du robot pour éviter qu'il apparaisse à l'intérieur
d'un obstacle.
void secureSpawn(){
for(int k = x*gC-(5*gC); k < x*gC+(5*gC); k+=gC){
for(int l = y*gC-(5*gC); l < y*gC+(5*gC); l+=gC){
ma[k/gC][l/gC] = 0;
}
}
}
//OBJET OBSTACLE
class Obstacles {
int ox;
int oy;
int ox2;
int oy2;
Obstacles(int xo,int yo,int txo,int tyo){
ox = xo;
//ox : coordonnées x de l'obstacle
oy = yo;
//oy : coordonnées y de l'obstacle
ox2 = txo;
//ox2 : longueur x de l'obstacle
oy2 = tyo;
//oy2: longueur y de l'obstacle
}
void display(){
//Nous avons recréé la fonction rect() de processing, mais pour pouvoir l'utiliser dans la matrice.
ox2 = ox + ox2*gC;
oy2 = oy + oy2*gC;
for(int k = ox; k < ox2; k+=gC){
for(int l = oy; l < oy2; l+=gC){
ma[k/gC][l/gC] = 2;
//Chaque case ayant les coordonnées balayées par la double boucle for prennent la valeur 2
(obstacle caché).
}
}
}
}
//Méthode qui sert à créer, avec des coordonnées et des grandeurs aléatoires, des obstalces.
void genObstacles() {
for(int i=0;i<int(random(5,10));i++){
Obstacles obstacle = new
Obstacles(int(random(0,sX)),int(random(0,sY)),int(random(2,gC*2)),int(random(2,gC*2)));
obstacle.display();
}
}
//Cette méthode sert à afficher ou à cacher les obstacles en fonction de affichageObstacle
void mAffObs(){
int u = i/gC;
int v = j/gC;
if(affObs == true){
//Si la boolean est vrai alors les obstacles apparaissent en
prenant pour valeur 3 (obstacles affichés).
if(ma[u][v] == 2){ma[u][v] = 3;}
}
if(affObs == false){
//Si elle est fausse alors les obstacles prennent la valeur 2
(obstacles cachés).
if(ma[u][v] == 3){ma[u][v] = 2;}
}
}
}
}
//Méthode qui affiche un cadre qui n'est pas influencé par le quadrillage.
void cadre(){
rect(0,gC,gC,sY-2*gC);
rect(gC,0,sX-2*gC,gC);
rect(sX-gC,gC,gC,sY-2*gC);
rect(gC,sY-gC,sX-2*gC,gC);
}
//Création de l'objet Slide.
class Slide extends JSlider { //Créer un Slider...
Slide(){
this.setPreferredSize(new Dimension(250,200));
this.setMaximum(100);
// avec ses dimensions,
// sa valeur maximum,
this.setMinimum(0);
this.setValue(v);
// sa valeur minimum,
// valeur que le slide à au début,
this.setPaintTicks(true);
this.setPaintLabels(true);
this.setMinorTickSpacing(10);
//l'écart entre chaque petit tirés,
this.setMajorTickSpacing(20);
//l'écart entre chaque grand tirés.
this.addChangeListener(new ChangeListener(){
//Il "écoute" chaque modification apporté,
void stateChanged(ChangeEvent event){
v=((JSlider)event.getSource()).getValue()+1;
//S'il trouve qu'il y a une modification la valeur v change.
println(v);}
});
}
}
//Créer l'objet Pan
class Pan extends JPanel {
Pan(int x,int y,int tx, int ty){
this.setSize(tx,ty);
this.setLocation(x,y);
this.setVisible(true);
}
}
//Création de l'objet Slide2
class Slide2 extends JSlider { //Créer un deuxième Slider...
Slide2(){
this.setPreferredSize(new Dimension(250,100)); //ses dimension
this.setMaximum(50);
this.setMinimum(0);
this.setValue(compteurAmpliMax);
//sa valeur maximum
//sa valeur minimum
//sa valeur de départ
this.setPaintTicks(true);
this.setPaintLabels(true);
this.setMinorTickSpacing(5);
//l'écart entre chaque petit tirés,
this.setMajorTickSpacing(10);
//l'écart entre chaque grands tirés,
this.addChangeListener(new ChangeListener(){
//Il "écoute" chaque modification apporté,
void stateChanged(ChangeEvent event){
compteurAmpliMax=((JSlider)event.getSource()).getValue()+1;compteurAmpli = 0;}});
//S'il trouve qu'il y a une modification la valeur compteurAmpli change.
}
}
//Méthode servant à afficher le cadriallage en fonction de la boolean affNoStroke.
void affNoStroke() {
if(affNoStroke == true) {
stroke(#A2A2A2);
}
else {
noStroke();
}
}
ONGLET 4
PFrame f = new PFrame(); //Crée une nouvelle fenêtre
class PFrame extends JFrame { //Crée une classe PFrame qui hérite des caractéristique de la classe
JFrame
//qui est en fait la classe qui crée une fenêtre en JAVA
PFrame() {
this.setSize(700, 400);
//Attribution de la taille a notre fenêtre
this.setTitle("Paramètres du robot");
//le titre
this.setLocationRelativeTo(null);
//la fenetre sera au centre de l'écran
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Si on ferme la fenêtre, tout le
programme s'arrete
ButtonGroup groupe = new ButtonGroup(); //Crée un nouveau groupe de bouton nommé groupe
ButtonGroup groupe2 = new ButtonGroup(); //...
ButtonGroup groupe3 = new ButtonGroup(); //...
Pan panel = new Pan(370,-65,250,150); //crée un nouvel objet nommé panel, on lui attribue une
taille et une localisation
Pan panel2 = new Pan(40, 17,200,20); //...
Pan panel3 = new Pan(41, 90,200,20); //...
Pan panel4 = new Pan(350, 90,300,30); //...
Pan pan2 = new Pan(40,170,250,20);
//...
Pan pan1 = new Pan(370,135,250,100); //...
Pan panel10 = new Pan(10,10,10,10); //...
Pan panGroup2 = new Pan(400,250,200,50); //...
Pan textGroup2 = new Pan(24,250,200,20); //...
Pan panGroup3 = new Pan(400,300,200,50); //...
Pan textGroup3 = new Pan(24,300,200,20); //...
Slide slide = new Slide();
//Créé un nouveau slider nommé slide
Slide2 slide2 = new Slide2(); //...
final JRadioButton but1 = new JRadioButton("Cyan"); // nouveau bouton qui portera l'inscription
Cyan a l'écran
final JRadioButton but2 = new JRadioButton("Rouge"); // Le mot-clé "final" indique que ces
bouton ne pourront pas
final JRadioButton but3 = new JRadioButton("Vert"); // modifié dans la suite du programme.
final JRadioButton but4 = new JRadioButton("Activer");
final JRadioButton but5 = new JRadioButton("Désactiver");
final JRadioButton but6 = new JRadioButton("Afficher");
final JRadioButton but7 = new JRadioButton("Cacher");
//Ces trois méthodes servent à changer les couleurs du robot en fonction du bouton validé.
but1.addActionListener(new ActionListener() {
// "Action listener" cette méthode va ecouter
pendant
void actionPerformed(ActionEvent e) {
// toute la durée du programme, quand on actionne
le bouton
if(but1.isSelected() == true) {coul = #00F4FF;} // le programme execute "coul = #00F4FF".
}});
//...
if(but2.isSelected() == true) {coul = #FF0000;}
}});
//...
if(but3.isSelected() == true) {coul = #14FF00;}
}});
//Ces méthodes servent à afficher ou non le quadrillage
if(but4.isSelected() == true) {affNoStroke = true;} //si le bouton est sélectionné, alors le boolean
affNoStroke est "true".
}});
if(but5.isSelected() == true) {affNoStroke = false;} //Si le bouton est sélectionné, alors le
boolean affNoStroke est "false".
}});
//par la suite ces booleans apparaissent dans une méthodes affNoStroke() qui va afficher, ou non, le
quadrillage
//Celles-ci servent à afficher ou non les obstacles
if(but6.isSelected() == true) {affObs = true;} //...
}});
if(but7.isSelected() == true) {affObs = false;}//...
}});
//...
groupe.add(but1); //on ajoute au groupe de bouton "groupe" le bouton "but1".
groupe.add(but2); //pour qu'un seul des bouton 1,2 et 3 ne soit actionnable
groupe.add(but3); //en meme temps
groupe2.add(but4); //on ajoute au groupe de bouton "groupe2" le bouton "but4".
groupe2.add(but5); //...
panel4.add(but1); //on ajoute les bouton au panel pour qu'ils soit visible dedans
panel4.add(but2);
panel4.add(but3);
panel.add(slide); //on ajoute les sliders au panel pour qu'ils soit visible dedans
pan1.add(slide2);
panGroup2.add(but4);
panel2.add(new JLabel("Modifiez la vitesse du robot : ")); //on ajoute des inscription à l'écran
panel3.add(new JLabel("Modifiez la couleur du robot : "));
pan2.add(new JLabel("Modifiez l'amplitude des mouvement : "));
textGroup2.add(new JLabel("Afficher le quadrillage : "));
textGroup3.add(new JLabel("Afficher les obstacles : "));
this.add(panGroup2); // "this" représente notre seconde fenêtre.
this.add(textGroup2); // Nous ajoutons donc tout les panels et inscription que nous avons
préalabement crée
this.add(panGroup3);
this.add(textGroup3);
this.add(pan2);
this.add(pan1);
this.add(panel);
this.add(panel2);
this.add(panel3);
this.add(panel4);
this.add(panel10);
this.setVisible(true); //on rend notre fenêtre visible
}
}
FIN PROCESSING
ARDUINO
int Moteur = 3;
int dMoteur = 2;
int serMoteur = 9;
int dSerMoteur = 8;
int interrup = 4;
int i = 0;
boolean interrupt = false;
void setup() {
pinMode(Moteur,OUTPUT);
pinMode(dMoteur,OUTPUT);
pinMode(serMoteur,OUTPUT);
pinMode(dSerMoteur,OUTPUT);
pinMode(interrup,INPUT);
digitalWrite(interrup,HIGH);
}
void loop() {
if(digitalRead(interrup) == LOW){
digitalWrite(dMoteur,LOW);
analogWrite(Moteur,250);
analogWrite(serMoteur,250);
delay(5000);
}
else{
digitalWrite(dMoteur,HIGH);
analogWrite(Moteur,250);
analogWrite(serMoteur,0);
}
}

Robot capable de dÃ©tecter et d`afficher des obstacles

Transcription

Similar documents

sujet - UniversitÃ© de Picardie Jules Verne

sujet - UniversitÃ© de Picardie Jules Verne

SÃ©rie 2

TP1 - UniversitÃ© de Picardie Jules Verne

SÃ©rie de TP NÂ°3

DESCRIPTION DU PROJET ROBOTIQUE

sujet - UniversitÃ© de Picardie Jules Verne

Équipement de soudage laser pour panneaux solaires thermiques

sujet - UniversitÃ© de Picardie Jules Verne

UE MÃ©thodes Quantitatives 2 Partie 1 : Analyse Syllabus et

la TV d`Orange sur tous vos Ã©crans