Réalisation d'un robot téleguidé

Ministère de l’enseignement supérieur
et de la Recherche Scientifique
Département IEEE
Mémoire de Projet de Fin d’Année
présenté pour l’obtention du
Diplôme National d’Ingénieur en
Electricité et Automatique
et réalisé par
Mohamed Amine LABIDI
Wael ZOUAGHI
Sujet : Réalisation d’un robot téléguide
Soutenu le 11/05/2018 devant le jury d’examen composé de :
M. Maher Ben HRIZ Encadreur Universitaire
M. Mohamed Khalil KHRICHI Encadreur Universitaire
Mme. Khawla ASADI Encadreur Universitaire

Photo de l’étudiant(e)
Résumé : (en Français)
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
Mots-clés :
……………………………………………………………………………………
……………………………………………………………………………………
Résumé : (en Anglais)
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
Abstract :
……………………………………………………………………………………
……………………………………………………………………………………
Nom et Adresse de l’établissement où a été réalisé le Projet de Fin d’Etude :
Nom :………………………………………………………………………………….……………………….
Adresse :……………………………………………………………………………….….……………………
………………………………………………………………………………………….….…………………..
Téléphone :…………………………………
Email :………………………………………

1
Réalisation d’un robot téléguidé

2
Remerciement
Je tiens à remercier toutes les personnes qui ont contribué au succès de mon projet et qui m'ont
aidé lors de la rédaction de ce rapport.
Tout d'abord, j'adresse mes remerciements à mes professeurs et mes encadreurs Mr. Maher Ben
Hriz et Mr. Mohamed Khalil Khrichi.
Et Je remercie la société Sebcom Ben Nour d’électroniques et la société SELI pour les
réductions de prix.
Enfin, je tiens à remercier toutes les personnes qui m'ont conseillé et relu lors de la rédaction de
ce rapport de projet.

3
Résumé
Dans ce projet nous avons fait dans le cadre dans mon étude et dans le cadre d’une compétition
de faire un robot téléguidé commandé par un Smartphone lions le robot et le Smartphone avec un
réseau wifi local distribué par le Smartphone.

4
Tableau de matières
Introduction générale ...................................................................................................................................7
Chapitre I : Cahier de charge.........................................................................................................................8
Introduction ..............................................................................................................................................8
1. Problématique ..................................................................................................................................8
2. Cahier de charge ...............................................................................................................................8
Conclusion.................................................................................................................................................8
Chapitre II : Phase d’élaboration ..................................................................................................................9
Introduction ..............................................................................................................................................9
1. Partie mécanique..............................................................................................................................9
a. Le châssis.......................................................................................................................................9
b. Les mouvements de robot..........................................................................................................10
2. Partie informatique.........................................................................................................................13
a. Langage de programmation........................................................................................................13
b. Modélisation UML.......................................................................................................................14
3. Etude de réseaux.............................................................................................................................16
a. La typologie de réseau................................................................................................................17
4. Etude électronique..........................................................................................................................17
a. Les composants de partie électronique......................................................................................17
b. Etude de fonctionnement...........................................................................................................24
Conclusion...............................................................................................................................................28
Chapitre III : Partie Réalisation ...................................................................................................................29
Introduction ............................................................................................................................................29
1. Partie mécanique............................................................................................................................29
2. Partie informatique.........................................................................................................................30
3. La partie réseau...............................................................................................................................31
4. Partie électronique .........................................................................................................................32
Conclusion...............................................................................................................................................33
Conclusion générale....................................................................................................................................34
Annexe ........................................................................................................................................................36
1. Annexe A.........................................................................................................................................36
2. Annexe B .........................................................................................................................................38

5
3. Annexe C .........................................................................................................................................49

6
Tableau de figure
Figure 1: Des panneaux en ALUCOBOND......................................................................................................9
Figure 2: Préparation de la cache extérieur pour le robot sur Autocad.....................................................10
Figure 3: Schéma synoptique démontre les roues sans mouvement.........................................................11
Figure 4: Schéma synoptique démontre les roues en mouvement (Forward)...........................................11
Figure 5: Schéma synoptique démontre les roues en mouvement (Backward).........................................12
Figure 6: Schéma synoptique démontre les roues en mouvement (Turn_Right).......................................12
Figure 7: Schéma synoptique démontre les roues en mouvement (Turn_Left).........................................13
Figure 8: Diagramme de cas d'utilisation de notre système de robot........................................................15
Figure 9: L'intégration de HTML dans la programmation C de la carte Arduino........................................16
Figure 10: Schéma synoptique démontre les flux de données entre le serveur http et le client
Smartphone ................................................................................................................................................17
Figure 11: La topologie de réseau entre le Smartphone ET le robot représenté avec Cisco Packet Tracer
....................................................................................................................................................................17
Figure 12: Moteur utilisé dans les roues de robot......................................................................................18
Figure 13: Carte Arduino UNO ....................................................................................................................19
Figure 14: Le module cc3000 Wifi Shield....................................................................................................20
Figure 15: fixer le module Wi-Fi sur la carte Arduino UNO ........................................................................21
Figure 16: Le module moteur Shield utilisé ................................................................................................21
Figure 17: Bouton d'urgence utilisé............................................................................................................22
Figure 18: Le connecteur XT60 ...................................................................................................................23
Figure 19: Batterie LiPo utilisé ....................................................................................................................24
Figure 20: Schéma Synoptique qui décrire le réseau électrique ................................................................25
Figure 21: Flowchart le programme implémenté dans la carte Arduino liée au module moteur..............26
Figure 22: Flowchart correspond au programme implémenté dans la carte Arduino liée au Module Wifi
....................................................................................................................................................................27
Figure 23: la face au-dessous......................................................................................................................29
Figure 24: La face au-dessus .......................................................................................................................30
Figure 25: L'interface de contrôle...............................................................................................................31
Figure 26: Point d'accès HUAWEI_SCL-21_D18C........................................................................................32
Figure 27: Câblage entre les différents composants électroniques ...........................................................33

7
Introduction générale
Dans ce projet nous avons réalisé un robot téléguidé en utilisons deux carte Arduino UNO, Wifi
Shield CC3300, deux moteur a courant continue et un moteur Shield.
Le but c’est de réaliser les parties mécanique, électrique, réseau et informatique de robot. En
expliquant le fonctionnement de ce que j’ai réalisé.
Ce rapport est divisé en trois chapitres :
Dans le premier chapitre nous présentons le cahier de charge avec la problématique du
robot téléguidé.
Dans le deuxième chapitre nous détaillons l’étude fonctionnelle mécanique,
électronique, réseaux et informatique.
Le troisième chapitre est dédié à la partie réalisation du robot téléguidé.

8
Chapitre I : Cahier de charge
Introduction
Dans ce chapitre en va présenter le cahier de charge et la problématique pour faire un robot
téléguidé.
1. Problématique
Un robot commandé qui peut faire les actions suivantes : Marche avant ; Marche Arrière ;
Tourne à gauche ; Tourne à droite.
2. Cahier de charge
Le robot doit être commandé quel que soit la technologie qui lié le robot au partie de commande
par exemple : Wifi, Bluetooth, infrarouge ou câblé.
La partie commande doit être compréhensible par l’operateur.
Il faut qu’il bien répondre à nos ordre chaque ordre est liée à une action :
-Marche avant
-Marche arrière
-tourne à gauche
-tourne à droite
Conclusion
Dans ce projet en serons capable de utilisé nos connaissances pour fabriquer ce robot.

9
Chapitre II : Phase d’élaboration
Introduction
Dans ce chapitre en va étudier comment il fonctionne ? En va s’intéressée au fonctionnement
globale jusqu’à l’étude mécanique, informatique, réseau et électronique.
En va faire un robot avec deux roues et une roue libre contrôlée par deux cartes Arduino UNO,
Arduino Motors Shield et Arduino Wifi Shield.
1. Partie mécanique
a. Le châssis
Le châssis est très important pour assembler les diffèrent part de robot tels que les roues les
moteurs les cartes électroniques la buttons d’urgence.
Le composite utilisé dans le châssis c’est de l’ALUCUBOND est un panneau composite
constitué de deux tôles de parement aluminium et d'un noyau en plastique la figure 1 montre
l’ALUCOBON.
La premier partie de châssis elle était acheté de kit Arduino les places des moteurs sont déjà
préparé avec la place d’une seule carte Arduino UNO ou Leonardo responsable d’utilisation de le
Motors Shield.
Alors j’étais obligé de faire un cache extérieur pour fixer le bouton d’urgence et une base pour la
carte Arduino UNO utilisé pour la communication wifi.
Figure 1: Des panneaux en ALUCOBOND

10
J’ai préparé le cache extérieur sur AutoCad pour la découpage numérique.
Figure 2: Préparation de la cache extérieur pour le robot sur Autocad
b. Les mouvements de robot
Le mode freinage (Brake)
Initialement les roues sont en mode freinage comme le schéma si dessous les roues ne tourne pas
le trait en rouge si il y a une tête de flèche sur le trait cela démontre la direction de mouvement
de roue.

11
Figure 3: Schéma synoptique démontre les roues sans mouvement
Le mode marche avant (Forward)
Les deux roues se dirigent en avant comme le schéma si dessous les roues se dirigent en avant la
flèche rouge démontre la direction des roues.
Figure 4: Schéma synoptique démontre les roues en mouvement (Forward)
Le mode marche arrière (Backward)
Les deux roues se dirigent en arrière comme le schéma si dessous les roues se dirigent en arrière
la flèche rouge démontre la direction des roues.

12
Figure 5: Schéma synoptique démontre les roues en mouvement (Backward)
Le mode tourné à droite (Turn_Right)
Le roue gauche se dirige en avant et le roue droite se dirige en arrière pour que le robot tourne a
son place comme le schéma va se démontre au-dessous.
Figure 6: Schéma synoptique démontre les roues en mouvement (Turn_Right)
Le mode tourné à gauche (Turn_Left)
Le roue gauche se dirige en arrière et le roue droite se dirige en avant pour que le robot tourne a
son place comme le schéma va se démontre au-dessous.

13
Figure 7: Schéma synoptique démontre les roues en mouvement (Turn_Left)
2. Partie informatique
a. Langage de programmation
HTML
L’Hypertext Markup Language, généralement abrégé HTML, est le format de données conçu
pour représenter les pages web. C’est un langage de balisage permettant d’écrire de l’hypertexte,
d’où son nom. HTML permet également de structurer sémantiquement et de mettre en forme le
contenu des pages, d’inclure des ressources multimédias dont des images, des formulaires de
saisie, et des programmes informatiques. Il permet de créer des documents interopérables avec
des équipements très variés de manière conforme aux exigences de l’accessibilité du web. Il est
souvent utilisé conjointement avec des langages de programmation (JavaScript) et des formats de
présentation (feuilles de style en cascade). HTML est initialement dérivé du Standard
Generalized Markup Language (SGML).
JAVASCRIPT
JavaScript est un langage de programmation de scripts principalement employé dans les pages
web interactives mais aussi pour les serveurs avec l'utilisation (par exemple) de Node.js. C'est un
langage orienté objet à prototype, c'est-à-dire que les bases du langage et ses principales
interfaces sont fournies par des objets qui ne sont pas des instances de classes, mais qui sont
chacun équipés de constructeurs permettant de créer leurs propriétés, et notamment une propriété

14
de prototypage qui permet d'en créer des objets héritiers personnalisés. En outre, les fonctions
sont des objets de première classe. Le langage supporte le paradigme objet, impératif et
fonctionnel. JavaScript est le langage possédant le plus large écosystème grâce à son gestionnaire
de dépendances npm, avec environs 500 000 paquets en août 2017.
JavaScript a été créé en 1995 par Brendan Eich. Il a été standardisé sous le nom d'ECMAScript
en juin 1997 par Ecma International dans le standard ECMA-262. Le standard ECMA-262 en est
actuellement à sa 8e édition. JavaScript n'est depuis qu'une implémentation d'ECMAScript, celle
mise en œuvre par la fondation Mozilla. L'implémentation d'ECMAScript par Microsoft (dans
Internet Explorer jusqu'à sa version 9) se nomme JScript, tandis que celle d'Adobe Systems se
nomme ActionScript.
La méthode AJAX
L'architecture informatique ajax (acronyme d'asynchronous JavaScript and XML) permet de
construire des applications Web et des sites web dynamiques interactifs sur le poste client en se
servant de différentes technologies ajoutées aux navigateurs web entre 1995 et 2005.
Ajax combine JavaScript, les CSS, JSON, XML, le DOM et le XMLHttpRequest afin
d'améliorer maniabilité et confort d'utilisation des applications internet riches (abr. RIA)1,2 :
DOM et JavaScript permettent de modifier l'information présentée dans le navigateur en
respectant sa structure ;
l'objet XMLHttpRequest sert au dialogue asynchrone avec le serveur Web ;
XML structure les informations transmises entre serveur Web et navigateur.
Outre le XML, les échanges de données entre client et serveur peuvent utiliser d'autres formats,
tels que JSON.
Les applications ajax fonctionnent sur tous les navigateurs Web courants : Google Chrome,
Safari, Mozilla Firefox, Internet Explorer, Konqueror, Opera, etc.
b. Modélisation UML

15
Diagramme de cas d'utilisation
Le diagramme de cas d’utilisation c’est un modelé informatique pour expliquer comment utiliser
l’application informatique.
Figure 8: Diagramme de cas d'utilisation de notre système de robot
L’intégration de la programmation HTML dans le code de c embarque de la carte Arduino la
figure ci-dessous démontre.

16
Figure 9: L'intégration de HTML dans la programmation C de la carte Arduino
3. Etude de réseaux
Le robot doit ce connecté à un point d’accès wifi de Smartphone.
Le Smartphone doit marcher comme un serveur DHCP qui génère une adresse IP (Internet
Protocole) dynamique vers le robot généralement le premier appareil connecté à ma Smartphone
sera de l’adresse IP 192.168.43.154 et le robot doit marcher comme un serveur http pour qu’il
génère un site web au réseau local sous le lien http://192.168.43.154/.
Comme la figure si dessous démontre le fonctionnement de serveur http.

17
Figure 10: Schéma synoptique démontre les flux de données entre le serveur http et le client Smartphone
a. La typologie de réseau
La topologie possible à un réseau liée avec la technologie wifi c’est la topologie maillé.
Figure 11: La topologie de réseau entre le Smartphone ET le robot représenté avec Cisco Packet Tracer
4. Etude électronique
a. Les composants de partie électronique
Moteur à courant continue
La photo de moteur est dans la figure ci-dessous ce moteur est acheter intègre directement dans
les roues sans fiche technique alors j’ai testé ce moteur sur 11.1v de la limite de tension que j’ai
dans la batterie LiPo 11.1v il est bien fonctionné sans anormalité il marche dans les deux sens a
courant continue en peut aussi contrôlé le vitesse en diminuant la tension avec un signal PWM
on peut dire aussi avec un hacheur abaisseur.

18
Figure 12: Moteur utilisé dans les roues de robot
Carte Arduino UNO
Arduino, et son récent synonyme Genuino, sont des cartes matériellement libres sur lesquelles se
trouve un microcontrôleur (d'architecture Atmel AVR comme par exemple l'Atmega328p). Les
schémas de ces cartes sont publiés en licence libre, cependant, certains composants, comme le
microcontrôleur par exemple, ne sont pas en licence libre.
Le microcontrôleur peut être programmé pour analyser et produire des signaux électriques, de
manière à effectuer des tâches très diverses comme la domotique (le contrôle des appareils
domestiques - éclairage, chauffage…), le pilotage d'un robot, de l'informatique embarquée, etc.
C’est une plate-forme basée sur une interface entrée/sortie simple. Il était destiné à l'origine
principalement mais pas exclusivement à la programmation multimédia interactive en vue de
spectacle ou d'animations artistiques.
C'est une partie de l'explication de la descendance de son environnement de développement de
Processing, lui-même inspiré de l'environnement de programmation Wiring (l'un pensé pour la
production d'applications impliquant des graphismes et l'autre pour pilotage de salles de
spectacles).
Arduino peut être utilisé pour construire des objets interactifs indépendants (prototypage rapide),
ou bien peut être connecté à un ordinateur pour communiquer avec ses logiciels (ex. :
Macromedia Flash, Processing, Max/MSP, Usine Hollyhock, Pure Data, SuperCollider). En 2011,

19
les versions vendues sont pré-assemblées. Des informations sont fournies pour ceux qui
souhaitent assembler ou construire une carte Arduino eux-mêmes.
Figure 13: Carte Arduino UNO
WIFI CC3000 Shield

20
Figure 14: Le module cc3000 Wifi Shield
Le module Wifi cc3000 Shield est un module qui ne permet d’utilisé la technologie wifi avec la
carte Arduino UNO il se fit de fixer le module directement sur la carte Arduino comme la figure
ci-dessous.

21
Figure 15: fixer le module Wi-Fi sur la carte Arduino UNO
Le module Motors Shield
Figure 16: Le module moteur Shield utilisé
Le module moteur pour Arduino («Arduino Motors Shield » en anglais) permet de contrôler
facilement la direction et la vitesse d’un moteur grâce à l’Arduino. En permettant d’accéder
facilement aux pins de l’Arduino, ce module permet d’ajouter facilement un moteur à tous vos
projets. Vous pouvez aussi alimenter un moteur avec une alimentation séparée (jusqu’à 12V). Le

22
mieux dans tout ça ? Le module est très facile à trouver, que ce soit sur internet ou dans des
magasins d’électronique.
Le module a 2 canaux, qui permettent de contrôler 2 moteurs DC ou un moteur pas à pas.
Il possède aussi 6 headers pour intégrer des entrées et sorties directes et des lignes de
communication.
Avec une alimentation externe, le module peut alimenter sans soucis jusqu’à 12V et 2A par canal
(ou 4A pour un seul canal).
Il y a des pins sur l’Arduino qui sont toujours utilisés par le module. En sélectionnant ces pins,
vous pouvez sélectionner un canal moteur à démarrer, choisir la direction du moteur (la polarité),
définir la vitesse du moteur, démarré et arrêter, et contrôler l’absorption de chaque canal.
Voici le numéro des pins :
Fonction Canal A Canal B
Direction Digital 12 Digital 13
Vitesse Digital 3 Digital 11
Frein Digital 9 Digital 8
Courant Analogue 0 Analogue 1
Bouton d’urgence
Figure 17: Bouton d'urgence utilisé
Le bouton se verrouille lorsqu'on appuie, tourner pour le relâcher.

23
Caractéristiques :
Type: ON/OFF
Pole: 2 pôles (NF-NO)
Voltage: 250V AC 3A / 30V DC 5A
Couleur du corps: noir
Couleur du bouton : rouge
Matière: plastique et métal
Poids : 10g
Connecteurs: 2.8mm
Diamètre perçage: 16mm
Diamètre bouton: 24mm
Dimensions à encastrer: 16 mm (Diamètre) x 30mm (Profondeur)
Dimensions totale: 23.4 mm (Diamètre) x 45 mm(Profondeur)
Les connecteurs XT60
Figure 18: Le connecteur XT60
J’ai utilisé ce connecteur pour que l’assemblage et la désassemblage soit rapide.

24
Batterie LiPo 11.1V
J’ai utilisé une batterie 11.1V de type LiPo parce que ce type de batterie est très puissant
généralement utilisé dans les aerobotics
La batterie qui j’ai utilisé génère 11.1V et 3000 mAh la photo ci-dessous.
Figure 19: Batterie LiPo utilisé
b. Etude de fonctionnement
La liaison électrique
Deux cartes Arduino séparé chaque carte joue un rôle important la carte Arduino avec le wifi
Shield ce communique en tant que un émetteur récepteur de donnée par la communication wifi et
marche en tant que émetteur de donnée pour la communication entre lui et la carte Arduino liée
au le module Motors Shield.
Tous les composant électronique sont alimenté par une batterie de type LiPo et le bouton
d’urgence coupe l’énergie électrique a tout le circuit sans exception.

25
Figure 20: Schéma Synoptique qui décrire le réseau électrique
L’algorithme de programme implémenté dans chaque carte
J’ai modélisé l’algorithme de programme qui sera implémenté dans chaque carte avec le model
de Flowchart.
La figure ci-dessous explique l’algorithme téléchargé dans la carte Arduino UNO liée au module
moteur.

26
Figure 21: Flowchart le programme implémenté dans la carte Arduino liée au module moteur
La figure ci-dessous explique l’algorithme correspond au programme télécharge dans la carte
Arduino UNO liée au module WIFI.

27
Figure 22: Flowchart correspond au programme implémenté dans la carte Arduino liée au Module Wifi
Explication écrite par étape
1- Le robot va se connecté dans le wifi correspond au téléphone.
2- Avec le téléphone je connecte au site web envoyé par le robot.

28
3- Puis j’envoie des requêtés de téléphone compréhensible par la carte Arduino liée au le
module Wifi.
4- La carte Arduino liée au le module Wifi convertie chaque requête à un nombre sera
envoyé directement vers la carte Arduino liée au module moteur.
5- Chaque nombre compréhensible par la carte Arduino liée au module moteur sera converti
à une action qui contrôle le sens et la vitesse de chaque moteur.
Conclusion
Dans cette partie j’ai identifié mes besoins et j’ai modélisé techniquement avant le lancement de
la réalisation de robot.

29
Chapitre III : Partie Implémentation
Introduction
Nous avons commencé par faire des expériences pratiques pour chaque module à part afin
d’aboutir à la réalisation complète du robot.
1. Partie mécanique
Le châssis était acheté précédemment mais le cache extérieur j’ai découpé avec la découpe
numérique et j’ai fait un trou de 16 mm pour fixer le bouton d’urgence et j’ai utilisé des tiges
filetée avec des écrous pour assembler la face au-dessus avec la face au-dessous.
Figure 23: la face au-dessous

30
Figure 24: La face au-dessus
2. Partie informatique
Dans la partie informatique j’ai programmé l’interface de commande en HTML et JavaScript
avec la méthode AJAX pourquoi j’ai utilisé la méthode Ajax chaque lorsque je click sur un
bouton la page sera actualisé alors il sera un charge sur la carte Arduino et peut interrupter le
serveur http alors sans actualisé la page je peux envoyer des requêtes.
Puis j’ai intégré la programme en HTML avec le programme de la carte Arduino.
Le programme dans l’annexe A
L’image sur l’interface finale

31
Figure 25: L'interface de contrôle
3. La partie réseau
J’ai défini le point d’accès dans le programme de la carte Arduino liée au module Wifi j’ouvre le
point d’accès de la téléphone et le robot va se connecter automatiquement au téléphone.
Comme dans la photo ci-dessous.

32
Figure 26: Point d'accès HUAWEI_SCL-21_D18C
4. Partie électronique
Apres avoir réalisé le circuit comme dans la partie d’élaboration le résultat physique final est
comme la figure ci-dessous.

33
Figure 27: Câblage entre les différents composants électroniques
En appliquant l’algorithme modèle la chapitre précédente.
Le programme de la carte d’Arduino liée au module Wifi dans l’annexe B.
Le programme de la carte d’Arduino liée au module moteur dans l’annexe C.
Conclusion
En regroupant toutes les parties et après des expériences faites sur le robot en constate que le
robot s’il se dépasse la limite de réseaux Wifi en peut perdre le contrôle de robot.

34
Conclusion générale
Le but de ce travail est vient dans le cadre d’étude et dans le cadre d’une compétition robotique
mais ce travail ne se limite pas à ça.
Le domaine robotique est utilisé dans d’autre domaine comme l’agriculture, médicale et militaire.
Et ce travail ne sera pas limité à cette années c’est reste à nous de le développer et de faire que ça.

35
Neto graphie
https://ouiaremakers.com/posts/tutoriel-diy-debuter-avec-le-module-moteur-arduino 09/05/2018
https://en.wikipedia.org/wiki/HTML 09/05/2018
https://fr.wikipedia.org/wiki/Ajax_(informatique) 09/05/2018
https://fr.wikipedia.org/wiki/JavaScript 09/05/2018

36
Annexe
1. Annexe A
<!DOCTYPE html>
<html>
<head>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<style>
* {
box-sizing: border-box;
}
.menu {
float: left;
width: 20%;
}
.menuitem {
text-align:center;
border-bottom: 1px solid #f1f1f1;
}
.main {
float: left;
width: 60%;
padding: 0 20px;
overflow: hidden;
}
.right {
background-color: lightblue;
float: left;
width: 20%;
padding: 10px 15px;
margin-top: 7px;
}
@media only screen and (max-width:800px) {
/* For tablets: */
.main {
width: 80%;
padding: 0;
}
.right {
width: 100%;
}
}
@media only screen and (max-width:500px) {
/* For mobile phones: */
.menu, .main, .right {
width: 100%;
}
}
.button {

37
background-color: #4CAF50; /* Green */
border: none;
color: white;
padding: 15px 32px;
text-align: center;
text-decoration: none;
display: inline-block;
font-size: 16px;
margin: 4px 2px;
cursor: pointer;
}
input[type=text] {
width: 100%;
padding: 12px 20px;
margin: 8px 0;
box-sizing: border-box;
font-size: 16px;
}
</style>
<script>
function Forward() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange=function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("demo").innerHTML = this.responseText;
}
};
xhttp.open("GET", "/1", true);
xhttp.send();
}
function Backward() {
}
};
xhttp.send();
}
function TurnLeft() {
}
};
xhttp.send();
}
function TurnRight() {

38
}
};
xhttp.send();
}
function Stop() {
}
};
xhttp.send();
}
</script>
</head>
<body style="font-family:Verdana;">
<div style="background-color:#f1f1f1;padding:15px;">
<h1>Control Interface</h1>
</div>
<div style="overflow:auto">
<div class="menu">
<div class="menuitem"><button class="button"
ontouchstart="Forward()" ontouchend="Stop()" >⏫</button></div>
<div class="menuitem">
<button ontouchstart="TurnLeft()" ontouchend="Stop()"
class="button">⏪</button>
<button ontouchstart="Stop()" ontouchend="Stop()"
class="button">✋</button>
<button ontouchstart="TurnRight()" ontouchend="Stop()"
class="button">⏩</button>
</div>
<div class="menuitem"><button ontouchstart="Backward()"
ontouchend="Stop()" class="button">⏬</button></div>
</div>
</div>
<div style="background-color:#f1f1f1;text-
align:center;padding:10px;margin-top:7px;font-size:12px;">This web
application is made by mohamed amine labidi</div>
</body>
</html>
2. Annexe B

39
#include <Adafruit_CC3000.h>
#include <SPI.h>
#include "utility/debug.h"
#include "utility/socket.h"
#include <SoftwareSerial.h>
SoftwareSerial Contr(8,9);
// These are the interrupt and control pins
#define ADAFRUIT_CC3000_IRQ 3 // MUST be an interrupt pin!
// These can be any two pins
#define ADAFRUIT_CC3000_VBAT 5
#define ADAFRUIT_CC3000_CS 10
// Use hardware SPI for the remaining pins
// On an UNO, SCK = 13, MISO = 12, and MOSI = 11
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS,
ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT,
SPI_CLOCK_DIVIDER); // you can
change this clock speed
#define WLAN_SSID "HUAWEI_SCL-L21_D18C" // cannot be longer than
32 characters!
#define WLAN_PASS "a3bf979b"
// Security can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, WLAN_SEC_WPA or
WLAN_SEC_WPA2
#define WLAN_SECURITY WLAN_SEC_WPA2
#define LISTEN_PORT 80 // What TCP port to listen on for
connections.
// The HTTP protocol uses port 80 by
default.
#define MAX_ACTION 10 // Maximum length of the HTTP action
that can be parsed.

40
#define MAX_PATH 64 // Maximum length of the HTTP
request path that can be parsed.
// There isn't much memory available
so keep this short!
#define BUFFER_SIZE MAX_ACTION + MAX_PATH + 20 // Size of
buffer for incoming request data.
// Since only
the first line is parsed this
// needs to be
as large as the maximum action
// and path plus
a little for whitespace and
// HTTP version.
#define TIMEOUT_MS 500 // Amount of time in milliseconds to
wait for
// an incoming request to finish.
Don't set this
// too high or your server could be
slow to respond.
Adafruit_CC3000_Server httpServer(LISTEN_PORT);
uint8_t buffer[BUFFER_SIZE+1];
int bufindex = 0;
char action[MAX_ACTION+1];
char path[MAX_PATH+1];
void setup(void)
{
pinMode(8, INPUT);
pinMode(9, OUTPUT);
Contr.begin(9600);
if (!cc3000.begin())
{
while(1);
}

41
if (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) {
while(1);
}
while (!cc3000.checkDHCP())
{
delay(100); // ToDo: Insert a DHCP timeout!
}
// Display the IP address DNS, Gateway, etc.
while (! displayConnectionDetails()) {
delay(1000);
}
httpServer.begin();
}
void loop(void)
{
// Try to get a client which is connected.
Adafruit_CC3000_ClientRef client = httpServer.available();
if (client) {
// Clear the incoming data buffer and point to the beginning of it.
bufindex = 0;
memset(&buffer, 0, sizeof(buffer));
// Clear action and path strings.
memset(&action, 0, sizeof(action));
memset(&path, 0, sizeof(path));
// Set a timeout for reading all the incoming data.
unsigned long endtime = millis() + TIMEOUT_MS;
// Read all the incoming data until it can be parsed or the timeout
expires.
bool parsed = false;
while (!parsed && (millis() < endtime) && (bufindex < BUFFER_SIZE)) {

42
if (client.available()) {
buffer[bufindex++] = client.read();
}
parsed = parseRequest(buffer, bufindex, action, path);
}
// Handle the request if it was parsed.
String info = String(path);
if(info.equals("/1")) Contr.write(1);
if (parsed) {
if (strcmp(action, "GET") == 0) {
client.fastrprintln(F("<!DOCTYPE html>"));
client.fastrprintln(F("<html>"));
client.fastrprintln(F("<head>"));
client.fastrprintln(F("<meta name="viewport"
content="width=device-width, initial-scale=1.0">"));
client.fastrprintln(F("<style>"));
client.fastrprintln(F("body {"));
client.fastrprintln(F(" -webkit-touch-callout: none; "));
client.fastrprintln(F(" -webkit-user-select: none;"));
client.fastrprintln(F(" -khtml-user-select: none; "));
client.fastrprintln(F(" -moz-user-select: none;"));
client.fastrprintln(F(" -ms-user-select: none; "));
client.fastrprintln(F(" user-select: none; }"));
client.fastrprintln(F("* {"));
client.fastrprintln(F(" box-sizing: border-box;"));
client.fastrprintln(F("}"));

43
client.fastrprintln(F(".menu {"));
client.fastrprintln(F(" float: left;"));
client.fastrprintln(F(" width: 20%;"));
client.fastrprintln(F(".menuitem {"));
client.fastrprintln(F(" text-align:center;"));
client.fastrprintln(F(" border-bottom: 1px solid #f1f1f1;"));
client.fastrprintln(F(".main {"));
client.fastrprintln(F(" padding: 0 20px;"));
client.fastrprintln(F(" overflow: hidden;"));
client.fastrprintln(F(".right {"));
client.fastrprintln(F(" background-color: lightblue;"));
client.fastrprintln(F(" padding: 10px 15px;"));
client.fastrprintln(F(" margin-top: 7px;"));
client.fastrprintln(F("@media only screen and (max-width:800px)
{"));
client.fastrprintln(F(" /* For tablets: */"));
client.fastrprintln(F(" .main {"));
client.fastrprintln(F(" padding: 0;"));
client.fastrprintln(F(" }"));
client.fastrprintln(F(" .right {"));

44
client.fastrprintln(F("@media only screen and (max-width:500px)
{"));
client.fastrprintln(F(" /* For mobile phones: */"));
client.fastrprintln(F(" .menu, .main, .right {"));
client.fastrprintln(F(".button {"));
client.fastrprintln(F(" background-color: #4CAF50; /* Green
*/"));
client.fastrprintln(F(" border: none;"));
client.fastrprintln(F(" color: white;"));
client.fastrprintln(F(" text-align: center;"));
client.fastrprintln(F(" text-decoration: none;"));
client.fastrprintln(F(" display: inline-block;"));
client.fastrprintln(F(" font-size: 16px;"));
client.fastrprintln(F(" margin: 4px 2px;"));
client.fastrprintln(F(" cursor: pointer;"));
client.fastrprintln(F("input[type=text] {"));
client.fastrprintln(F(" margin: 8px 0;"));
client.fastrprintln(F(" box-sizing: border-box;"));
client.fastrprintln(F(" font-size: 16px;"));
client.fastrprintln(F("</style>"));

45
client.fastrprintln(F("<script>"));
client.fastrprintln(F("function Forward() {"));
client.fastrprintln(F(" var xhttp = new XMLHttpRequest();"));
client.fastrprintln(F(" xhttp.onreadystatechange=function()
{"));
client.fastrprintln(F(" if (this.readyState == 4 &&
this.status == 200) {"));
client.fastrprintln(F("
document.getElementById("demo").innerHTML = this.responseText;"));
client.fastrprintln(F(" };"));
client.fastrprintln(F(" xhttp.open("GET", "/1", true);"));
client.fastrprintln(F(" xhttp.send();"));
client.fastrprintln(F("function Backward() {"));
client.fastrprintln(F(" var xhttp = new
XMLHttpRequest();"));
{"));
client.fastrprintln(F("function TurnLeft() {"));
{"));

46
client.fastrprintln(F("function TurnRight() {"));
{"));
client.fastrprintln(F("function Stop() {"));
{"));

47
client.fastrprintln(F("</script>"));
client.fastrprintln(F("</head>"));
client.fastrprintln(F("<body style="font-family:Verdana;">"));
client.fastrprintln(F("<div style="background-
color:#f1f1f1;padding:15px;">"));
client.fastrprintln(F(" <h1>Control Interface</h1>"));
client.fastrprintln(F("</div>"));
client.fastrprintln(F("<div style="overflow:auto">"));
client.fastrprintln(F(" <div class="menu">"));
client.fastrprintln(F(" <div class="menuitem"><button
class="button" ontouchstart="Forward()" ontouchend="Stop()"
>⏫</button></div>"));
client.fastrprintln(F(" <div class="menuitem">"));
client.fastrprintln(F(" <button ontouchstart="TurnLeft()"
ontouchend="Stop()" class="button">⏪</button>"));
client.fastrprintln(F(" <button ontouchstart="Stop()"
ontouchend="Stop()" class="button">✋</button>"));
client.fastrprintln(F(" <button
ontouchstart="TurnRight()" ontouchend="Stop()"
class="button">⏩</button>"));
client.fastrprintln(F(" </div>"));
client.fastrprintln(F(" <div class="menuitem"><button
ontouchstart="Backward()" ontouchend="Stop()"
class="button">⏬</button></div>"));
client.fastrprintln(F(" </div>"));
client.fastrprintln(F("</div>"));
client.fastrprintln(F("<div style="background-
color:#f1f1f1;text-align:center;padding:10px;margin-top:7px;font-
size:12px;">This web application is made by mohamed amine
labidi</div>"));
client.fastrprintln(F("</body>"));
client.fastrprintln(F("</html>"));
//client.fastrprintln(path);
}
else {

48
// Unsupported action, respond with an HTTP 405 method not allowed
error.
client.fastrprintln(F("HTTP/1.1 405 Method Not Allowed"));
client.fastrprintln(F(""));
}
}
// Wait a short period to make sure the response had time to send
before
// the connection is closed (the CC3000 sends data asyncronously).
delay(10);
client.close();
}
}
bool parseRequest(uint8_t* buf, int bufSize, char* action, char* path) {
// Check if the request ends with rn to signal end of first line.
if (bufSize < 2)
return false;
if (buf[bufSize-2] == 'r' && buf[bufSize-1] == 'n') {
parseFirstLine((char*)buf, action, path);
return true;
}
return false;
}
// Parse the action and path from the first line of an HTTP request.
void parseFirstLine(char* line, char* action, char* path) {
// Parse first word up to whitespace as action.
char* lineaction = strtok(line, " ");
if (lineaction != NULL)
strncpy(action, lineaction, MAX_ACTION);
// Parse second word up to whitespace as path.

49
char* linepath = strtok(NULL, " ");
if (linepath != NULL)
strncpy(path, linepath, MAX_PATH);
}
// Tries to read the IP address and other connection details
bool displayConnectionDetails(void)
{
uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv;
if(!cc3000.getIPAddress(&ipAddress, &netmask, &gateway, &dhcpserv,
&dnsserv))
{
return false;
}
else
{
return true;
}
}
3. Annexe C
#include <SoftwareSerial.h>
SoftwareSerial Contr(6,7);
int pass;
void setup() {
//Serial Communication
Contr.begin(9600);
//Setup Channel A
pinMode(12, OUTPUT); //Initiates Motor Channel A pin
pinMode(9, OUTPUT); //Initiates Brake Channel A pin
//Setup Channel B

50
pinMode(13, OUTPUT); //Initiates Motor Channel A pin
pinMode(8, OUTPUT); //Initiates Brake Channel A pin
pass = 0;
}
void loop() {
// put your main code here, to run repeatedly:
if(Contr.available() > 0)
{
pass = Contr.read();
}
if(pass == 2)
{
digitalWrite(13, LOW);
analogWrite(3, 100);
digitalWrite(12, HIGH);
}
if(pass == 1)
{
}
if(pass == 4)
{

51
delay(500);
pass = 0;
}
if(pass == 3)
{
delay(500);
pass = 0;
}
if(pass == 5 || pass == 0)
{
}
}

Réalisation d'un robot téleguidé

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Réalisation d'un robot téleguidé

Similaire à Réalisation d'un robot téleguidé (20)

Dernier

Dernier (11)

Réalisation d'un robot téleguidé