Vous êtes sur la page 1sur 30

Rapport De Stage

Sujet : Conception d’une calèche


autonome destinée aux personnes à
mobilité réduite

L3 option Electronique, Energie Electrique et Automatique


(EEA)

Période de stage : Année universitaire :


Du 06/01/2020 à 29/02/2020 2019/2020

Réalisé par : Encadré par :


Mohammed ABKARI MR. Ahmed RHALLBI
Thomas MOYON
REMERCIEMENTS

Nos remerciements les plus profonds à toute personne ayant contribué à la


réalisation de ce stage de loin ou de près.

Nous tenons à remercier les membres de l’institut des matériaux Jean Rouxel
pour nous avoir accueilli au sein de leur INSTITUT et de nous avoir accordé leur
confiance.

Nous adressons particulièrement nos remerciements au responsable de ce projet


Monsieur Ahmed RHALLABI de nous avoir aidé et suivi durant la période du
stage et le partage de son expérience qui nous a permis d’accomplir les
différentes tâches qui nous ont été attribuées.

Nous souhaitons remercier également nos professeurs pour leurs conseils


pertinents qui nous ont été d’un appui considérable tout au long du stage.

2
Sommaire
Chapitre 1 : Description générale
I. L’environnement économique du stage :.............................................................................................. 7
A. Présentation de l’IMN :.................................................................................................................................... 7
B. Secteur économique : ...................................................................................................................................... 7
II. L’IMN par rapport au secteur : .............................................................................................................. 8
A. Historique de l’IMN : ....................................................................................................................................... 8
B. Organigramme Général : ................................................................................................................................. 8
C. Organigramme du Plateau Technique : ............................................................................................................ 9
D. Organigramme Des Services Administratifs :.................................................................................................... 9
Chapitre 2 : Mise en situation

I. Présentation : ..................................................................................................................................... 11
A. Introduction : ................................................................................................................................................ 11
B. Le langage Python : ....................................................................................................................................... 12
C. La carte Raspberry Pi : ................................................................................................................................... 13
D. Le connecteur du Rasperry Pi : ...................................................................................................................... 14
II. Le matériel utilisé :.............................................................................................................................. 15
A. Le Robot Yahboom 4WD Car : ........................................................................................................................ 15
B. Potentiomètre : ............................................................................................................................................. 16
III. Configuration de Raspberry pi : .......................................................................................................... 16
Chapitre 3 : Prototype de projet
I. Introduction ........................................................................................................................................ 19
II. Potentiomètre manuel avec l’interface NODE-RED : .......................................................................... 20
A. LES COMPOSANTS DE LA PALETTE : ............................................................................................................... 20
B. L’installation de NODE-RED :.......................................................................................................................... 21
C. L’utilisation de NODE-RED : ........................................................................................................................... 21
III. Potentiomètre manuel avec le MCP4003 : .......................................................................................... 23
A. L’installation de MCP3004 ............................................................................................................................. 24
B. Programme : ................................................................................................................................................. 24
IV. Contrôle automatique :....................................................................................................................... 25
A. Carte de puissance : ...................................................................................................................................... 26
B. Moteurs électriques : .................................................................................................................................... 27
Conclusion
Bibliographie

3
Figure 1 : Vue du système guidage

Figure 2 : Vue du tableau de bord

Figure 3 : Vue de deux moteurs

Figure 4 : Les périphériques du Raspberry Pi

Figure 5 : Les éléments du Raspberry Pi

Figure 6 : GPIO

Figure 7 : Robot Yahboom 4WD Car

Figure 8 : Système d’exploitation NOOBS

Figure 9 : PUTTY mode de connexion via un autre pc

Figure 10 : Terminal

Figure 11 : La palette de composants

Figure 12 : Interface affichée sur la tablette

Figure 13 : DATASHEET de MCP3004

Figure 14 : Connexion entre le MCP3004 et les GPIO

Figure 15 : Les Pins

Figure 16 : Contrôle de vitesse

Figure 17 : Programme permettant de contrôler la vitesse

Figure 18 : Programme pour les capteurs et les deux moteurs

Figure 19 : Carte de puissance

Figure 20 : Carte de puissance connectée au Raspberry Pi

Figure 21 : Moteur électrique

4
Dans le cadre de notre troisième année de licence en Electronique, Energie Electrique et
Automatique à l’université de Nantes, nous avons passé un stage de 2 mois à l’institut des
matériaux JEAN ROUXEL à Nantes.

Ayant pour finalité la conception d’une calèche autonome destinée aux personnes à
mobilité réduite. Ayant une passion commune pour le Raspberry Pi et la domotique,
notre groupe composé de Mohammed ABKARI et Thomas MOYON, a saisi l’opportunité
d’exploiter cet intérêt commun pour soumettre l’ébauche d’un projet innovant au
responsable de stage M. Ahmed RHALLBI.

L’objectif est de créer un système de guidage à l’aide d’une raspberry pi et de deux


moteurs électriques pour permettre une production low cost, et modifiable à souhait.

Ce projet se découpe en deux parties faisant appel à nos compétences en Informatique et


en Electronique. La première se focalise sur la construction de montage entre les
différents dispositifs et la deuxième sur la création et l’implémentation des programmes
dans la carte Raspberry pi.

Ce rapport s’articule ainsi autour de trois grandes parties. La première partie est
réservée à la description générale de l’organisme d’accueil. La seconde partie propose
une mise en situation du projet et la dernière partie résume la méthodologie d’étude
du projet.

5
CHAPITRE

6
Chapitre I : Description générale

I. L’environnement économique du stage :

A. Présentation de l’IMN :

L’Institut des matériaux Jean Rouxel de Nantes fut créé en 1988 par Jean Rouxel.
Jean Rouxel est un chimiste français mondialement connu spécialisé dans la chimie inorganique à l’institut
des matériaux de Nantes et titulaire de la chaire de chimie des solides au Collège de France. Il est nommé
chevalier de la Légion d’honneur en 1988 et promu officier en 1997. En 1992 il obtient le Prix Humboldt
puis la médaille d’or du CNRS en 1997.
L’IMN regroupe plusieurs laboratoires de recherche qui travaillent sur les Nanosciences et les
Nanomatériaux. Dans l’Institut on y retrouve des laboratoires de Chimie et de Physique.
L’Institut des Matériaux de Nantes est l’un des principaux centres de recherche en matériaux en France

B. Secteur économique :

L’Institut des Matériaux est principalement tourné vers le domaine de la haute technologie
notamment dans l’industriel mais aussi dans l’institutionnel. L’Institut travaille avec des entreprises comme
Renault, STMicroelectronics, Total et bien d’autres encore.
L’IMN effectue des recherches sur les applications de nouveaux matériaux en fonction de leurs différentes
propriétés pour par exemple des cellules photovoltaïques, des piles à combustibles, des batteries pour des
véhicules électriques, les nanotechnologies ou encore des matériaux pour la mémoire, photoniques et
optiques.

7
II. L’IMN par rapport au secteur :

A. Historique de l’IMN :

La construction de l’IMN fut achevée en 1989, le bâtiment est séparé en deux par le hall d’entrée,
d’un côté on y trouve les laboratoires de Chimie et de l’autre les laboratoires de Physique.
À sa création, c’est-à-dire en 1988, l’Institut des Matériaux de Nantes regroupait trois laboratoires, le
laboratoire de Chimie des Solides, le laboratoire de Physique Cristalline et le laboratoire des Plasmas et
Couches Minces.
Puis en 2008, le laboratoire des Matériaux Photovoltaïques se joint aux laboratoires de l’IMN.
Enfin en 2012, le laboratoire de Génie des Matériaux et Procédés Associés s’unit aux laboratoires de
l’Institut.

B. Organigramme Général :

8
C. Organigramme du Plateau Technique :

D. Organigramme Des Services Administratifs :

9
CHAPITRE

II

10
CHAPITRE II : Mise en situation

I. Présentation :

A. Introduction :

Le projet a été aborder par les masters, ils ont travaillé sur la partie énergétique ; la régulation de
tension et l’alimentation des différents dispositifs grâce aux panneaux solaires qui chargent les batteries,
et aussi le contrôle de la calèche manuellement. Ils ont aussi fait un design de la calèche à l’aide du logiciel
AUTOCAD.

Figure 1 : Vue du système guidage Figure 2 : Vue du tableau de bord

Donc notre mission était portée sur la partie de contrôle et de guidage de la calèche automatiquement
avec des capteurs d’obstacles et de suivi de ligne à base du Raspberry Pi en utilisant le langage de
programmation PYTHON. Pour atteindre notre objectif, nous avons utilisé un robot afin de tester les codes,
fourni avec, qui servent à contrôler la vitesse et le sens de rotation des moteurs ainsi que les codes servant
au robot de suivre une ligne à l’aide des capteurs infrarouges. Donc notre travail consiste à démarrer les
deux moteurs ; le premier est mis à l’arrière pour avancer et reculer et le deuxième à l’avant pour faire
tourner les roues à gauche et à droite.

11
Figure 3 : Vue des deux moteurs

B. Le langage Python :

Python est un langage de programmation (au même titre que le C, C++, Fortran, Java . . .), développé en
1989. Ses principales caractéristiques sont les suivantes :
 « Open-source » : son utilisation est gratuite et les fichiers sources sont disponibles et modifiables ;
 Simple et très lisible ;
 Doté d’une bibliothèque de base très fournie ;
 Importante quantité de bibliothèques disponibles : pour le calcul scientifique, les statistiques, les
bases de données, la visualisation . . . ;
 Grande portabilité : indépendant vis à vis du système d’exploitation (Linux, Windows, MacOS) ;
 Les objets orientés ;
 Typage dynamique : le typage (association à une variable de son type et allocation zone mémoire
en conséquence) est fait automatiquement lors de l’exécution du programme, ce qui permet une
grande flexibilité et rapidité de programmation, mais qui se paye par une surconsommation de
mémoire et une perte de performance ;
 Présente un support pour l’intégration d’autres langages.
Il existe deux techniques principales pour traduire un code source en langage machine :

12
 La compilation : une application tierce, appelée compilateur,
transforme les lignes de code en un fichier exécutable en langage machine. A chaque fois que l’on
apporte une modification au programme, il faut le recompiler avant de voir le résultat.
 L’interprétation : un interpréteur s’occupe de traduire ligne par ligne le programme en langage
machine. Ce type de langage offre une plus grande commodité pour le développement, mais les
exécutions sont souvent plus lentes.
Dans le cas de Python, on peut admettre pour commencer qu’il s’agit d’un langage interprété, qui fait
appel des modules compilés. Pour les opérations algorithmiques coûteuses, le langage Python peut
s’interfacer à des bibliothèques écrites en langage de bas niveau comme le langage C.

C. La carte Raspberry Pi :

Raspberry Pi est un petit ordinateur sous le système d’exploitation Linux sur carte SD destiné à des
applications d’informatique embarquée. Le cœur de l’ordinateur est un FPGA (Broadcom 2835) intégrant
un processeur ARM11 cadencé à 700MHz et de nombreux périphériques. Raspberry Pi peut être
directement connecté à une IHM classique, souris/clavier/écran HDMI ou vidéo composite, cependant
comme tout ordinateur fonctionnant sous Linux, le Raspberry Pi peut intégrer ses propres outils de
développement et une interface homme‐machine reposant sur un SSH contrôlable depuis un autre
ordinateur via Ethernet ou WIFI. Le connecteur d’extension supporte les entrées/sorties parallèles ainsi
que la plupart des bus de communication. C’est un support particulièrement économique et puissant qui
peut être facilement mis en œuvre dans de petits systèmes nécessitant un accès au monde physique
par des capteurs/actionneurs disposants d’interfaces numériques.

Figure 4 : Les périphériques du Raspberry Pi

13
Figure 5 : Les éléments du Raspberry Pi

D. Le connecteur du Rasperry Pi :

Le connecteur GPIO (General Purpose Input Output) comprend 40


broches réparties sur 2 rangées. Il comporte 29 E/S numériques, une
interface I2C, une interface SPI et une interface UART. Les broches du
GPIO sont repérées soit par le numéro du connecteur GPIO (Board) ou
bien par le numéro de la ligne d’E/S au niveau du P (BCM).

Toutes les broches du connecteur GPIO opèrent à 3,3 V mise à part


deux sortie 5V. La carte Raspberry ne dispose d’aucune protection
contre les surtensions. Si par mégarde une tension de 5 V est
appliquée sur une entrée GPIO, le Raspberry sera détruit.

Figure 6 : GPIO

14
II. Le matériel utilisé :

A. Le Robot Yahboom 4WD Car :

On a utilisé un robot Raspberry Pi 4WD Car, pour tester les codes de guidage et de variation de vitesse
afin de l’utiliser de notre projet. Le robot est constitué de :
 4 moteurs à Courant continu
 Détecteur d’obstacle
 Suiveur de ligne
 Carte Raspberry Pi
 Une caméra
 Des servomoteurs
 Suiveur de lumière
 Capteurs infrarouges

Tous les programmes sont transférés à la carte Raspberry Pi via la carte SD.

Figure 7 : Robot Yahboom4WD Car

15
B. Potentiomètre :
Un potentiomètre est un type de résistance variable à trois limites, dont une est reliée à un curseur
se déplaçant sur une piste résistante terminée par les deux autres limites.
Ce dispositif sert à recueillir, sur la limite reliée au curseur, une tension qui dépend de la position du
curseur et de la tension à laquelle est soumise la résistance.
Il existe l'équivalent sous forme de circuit intégré : le potentiomètre numérique, dorénavant
particulièrement utilisé dans l'électronique analogique à commande numérique moderne. Les
potentiomètres sont fréquemment employés dans les circuits électroniques. Ils servent par exemple à
contrôler le volume d'une radio.

III. Configuration de Raspberry pi :

Pour utiliser le Raspberry pi on a téléchargé la version NOOBS c’une collection de différents systèmes
d'exploitation pour le Raspberry Pi qui contient notamment Raspbian. En plus de Raspbian, NOOBS
comprend également Pidora, LibreELEC, OSMC, RISK OS, Arch Linux, Windows 10 IOT Core et quelques
autres.

Figure 8 : Système d’exploitation NOOBS

Les versions précédentes de Raspbian (antérieures à novembre 2016) avaient SSH activé par défaut. Ils
avaient également un nom d’utilisateur « pi » et un mot de passe « framboise » par défaut, ce qui facilitait
la configuration initiale des nouveaux utilisateurs. Mais cela représente évidemment une grande faille de
sécurité. La nouvelle version (novembre 2016) désactive SSH par défaut et affiche également un
avertissement si SSH est activé sans modifier le mot de passe par défaut, Donc on a activé le mode SSH afin
de contrôler la carte avec nos ordinateurs via PUTTY ou VNC-VIEWER.

16
Figure 9 : PUTTY mode de connexion via un autre pc

Ensuite on a mis la carte à jour, pour procéder à la mise à jour du système, il est nécessaire d’utiliser le
terminal : tout d'abord, on a procédé à la mise à jour des paquets présents :
Dans l'invité de commande on tape : sudo apt-get update

Cela peut prendre quelques minutes Une fois fini, le prompt pi@raspberrypi en vert se réaffiche, on peut
donc taper : sudo apt-get upgrade, pour la mise à jour des autres paquets cette phase est beaucoup plus
longue.

Figure 10 : Terminal

17
CHAPITRE

III

18
CHAPITRE III : Prototype de projet

I. Introduction

Ce chapitre est réparti en trois parties :


La première partie : c’est le guidage de la calèche par la carte Raspberry Pi en utilisant le mode NODE-RED.
La deuxième partie : c’est le guidage de la calèche par la carte Raspberry Pi en utilisant un potentiomètre.
La troisième partie : c’est de contrôler la calèche d’une maniéré automatique en utilisant des programmes
spécifiques pour les détecteurs d’obstacle et de la ligne.
On peut résumer notre travaille dans le schéma suivant :

Potentiomètre Mode NODE-RED

Convertisseur
Analogique
numérique

Capteurs d’obstacle et
Carte RASPBERRY PI
de ligne

Carte de puissance
RASPBERRY PI

Moteur Electrique

19
II. Potentiomètre manuel avec l’interface NODE-RED :

Pour faire varier la vitesse des moteurs, on a utilisé l’interface <<NODE-RED>>, il s’agit d’une
application reposant sur Node.js et permettant le design des chaînes de traitement dans un
environnement Web. NODE-RED fonctionne comme un ETL : une palette de connecteurs, des composants
de traitement et la possibilité de câbler le tout. Regardons maintenant un peu plus dans le détail.

A. LES COMPOSANTS DE LA PALETTE :

La palette des composants vient par défaut avec un ensemble de connecteurs plutôt complets. On
retrouve des composants permettant de lire « input » et écrire « output » des données, ainsi que plusieurs
autres catégories : des fonctions (split, join, range, delay, …), de l’analyse (un simple composant d’analyse
de sentiment par défaut), du stockage (file), etc. On trouve facilement en « input » et « output » de quoi
construire les premières bases d’une chaîne de traitement. Les types récurrents dans l’internet des objets
(IOT) sont présents (MQTT, http).

Heureusement, cette palette n’est qu’une base de départ. Il est possible de l’enrichir de plusieurs façons :

 En installant de nouveaux composants depuis la liste officielle des composants NODE-RED,


 En développant ses propres composants.

Figure 11 : La palette

20
B. L’installation de NODE-RED :

Pour utiliser le NODE-RED, on doit en premier lieu installer les bibliothèques et effectuer la mise à jour
de la palette :
 Commençons par ajouter un nouvel onglet au Terminal et saisissons la commande suivante qui va
arrêter NODE-RED.

 Node-Red utilise le gestionnaire de package npm de Nodejs (le moteur javascript de Node-Red).
Voici les étapes à suivre pour l’installer. On commence par mettre à jour le système

 Puis on installe npm

 Enfin on met à jour npm

C. L’utilisation de NODE-RED :

Dans notre projet, on a donc utilisé le NODE-RED afin de faire varier la vitesse de moteur, donc on a
intégré trois composants :
INPUT : on a choisi un « slider » comme une entrée qui permet de varier la vitesse en faisant glisser le
doigt sur l’écran du Raspberry. On peut aussi utiliser un potentiomètre numérique à la place du
« slider ».
GAUGE : on a utilisé une gauge afin d’afficher la vitesse de moteur (un peu comme sur le tableau de
bord d’une voiture).
OUTPUT : la sortie est liée directement au moteur, en choisissant le pin connecté au moteur.
Pour afficher l’interface de NODE-RED depuis un autre ordinateur ou tablette sur le réseau, on ouvre le
navigateur et on saisit dans la barre d’adresse.

21
Figure 12 : Interface affichée sur la tablette

Le programme de NODE-RED était testé sur le moteur continu de 5V de l’hélice.

REMARQUE :
 D’abord, pour notre projet, il est risqué d’utiliser le mode de NODE-RED, car tout le monde
peut contrôler la calèche en utilisant l’adresse IP et le numéro de port, pour cela, nous
avons trouvé une méthode qui est de créer un identifiant et un mot de passe avant
d’accéder au NODE-RED, qui sera à la disposition des personnes utilisant la calèche.
 Ensuite, pour avoir l’adresse IP, le Raspberry doit être connecté un réseau wifi mais lorsque
la calèche se déplacera, il sera difficile de garder la connexion, pour cela on peut utiliser le
Raspberry comme un routeur wifi.
 Enfin, l’utilisateur de la calèche doit entrer un petit code dans le terminal, pour activer le
mode NODE-RED :

22
III. Potentiomètre manuel avec le MCP4003 :

Comme la carte Raspberry Pi ne contient pas d’entrées analogiques on a dû utiliser un


convertisseur Analogique / Numérique (CAN) qui est donc le MCP4003.
Afin de varier la vitesse du moteur, on a utilisé un potentiomètre relié au MCP4003 qui permet donc de
convertir la valeur analogique à la sortie du potentiomètre puis d’envoyer la valeur numérique au
Raspberry.

Figure 13 : DATASHEET de MCP3004

Figure 14 : Connexion entre le MCP3004 et les GPIO

Le convertisseur est lié directement au GPIO de la carte.

Figure 15 : Les Pins

23
A. L’installation de MCP3004

Pour la partie dans laquelle on contrôle la vitesse des moteurs grâce à un potentiomètre, nous
avons utilisé un potentiomètre qui a une broche reliée à un CAN (le MCP3004), les deux autres sont reliées
au 3.3V et à la masse. Ce CAN dispose de quatre broches reliées au Raspberry Pi et deux broches reliées à
l’alimentation et à la masse, ce qui permet au Raspberry de pouvoir lire les valeurs du potentiomètre après
avoir écrit un code spécifique à ce CAN.
Donc en fonction de la valeur du potentiomètre, le Raspberry délivre un signal PWM vers la carte qui
permet le contrôle des moteurs (faire varier leur vitesse).
Nous devons aussi installer la bibliothèque permettant au Raspberry l’utilisation du CAN.

De plus il est nécessaire d’activer le mode SPI afin que le Raspberry puisse lire les entrées.
Pour installer la bibliothèque, il suffit de taper dans le terminal :

B. Programme :

Figure 16 : Contrôle de vitesse

24
Figure 17 : Programme permettant de contrôler la vitesse

Le programme a été testé sur le moteur continu de 5V de l’hélice.

IV. Contrôle automatique :

Pour le mode autonome, on va utiliser le capteur d’obstacle et de ligne, qui seront liés directement au
Raspberry pi, en utilisant le programme suivant :

25
Figure 18 : Programme pour les capteurs et les deux moteurs

Le programme a été testé sur les deux moteurs continu de 5V de deux roues.

A. Carte de puissance :

Dans les trois modes nous allons utiliser une carte de puissance pour moteurs compatible avec le
Raspberry Pi pour fournir une puissance suffisante aux moteurs, la carte est liée au Raspberry via les GPIO,
et celle-ci est basé sur deux ponts en H permet de contrôler deux moteurs CC jusqu'à 18 A par canal. Ce
module permet de contrôler la vitesse et le sens de rotation de deux moteurs sur deux canaux
indépendants.

Cette carte comporte une protection contre les courts-circuits, les inversions de polarité ou les
sous-tensions. Les broches de commandes moteurs peuvent être redéfinies via des pontets à souder.

Ce driver dispose d'une fonction de limitation du courant qui arrête le moteur pendant 25 µs lors
d'un pic de courant au démarrage. Ce seuil se règle avec une résistance à souder sur les pastilles « Vref ».

26
Les caractéristiques de ce driver :
 Alimentation : 6,5 à 30 Vcc
 Régulateur 5 Vcc/2,5 A intégré pour alimenter le Raspberry Pi
 Intensité maxi par canal : 18 A
 Fréquence PWM maxi : 100 kHz
 Leds d'indication Compatibilité : Raspberry Pi B+, A+, Pi2 et Pi 3
 Dimensions : 65 x 56 mm
 Poids : 30 g

Figure 20 : Carte de puissance connectée au Raspberry Pi


Figure 19 : Carte de puissance

B. Moteurs électriques :

Les caractéristiques de ces moteurs :


Plus grande Distance entre les trous (Centre de le œil au Centre de l’oeil) : 95 mm / 3,74 pouces
Tension: 24 V
Puissance: 300 W
Courant nominal: 16 A
Vitesse nominale: 2750 TR/MIN
Comprend pignon ? : Oui
TAILLE DE LA CHAÎNE: 6mm (25H)
Nombre de dents: 11
Épaisseur de pignon : 3 mm / 0,12 pouces
Diamètre du pignon (pointe de dent à la pointe de la dent) : 7 mm / 0,2 8 pouces
Longueur de l’arbre sur lequel se trouve le pignon : 21 mm / 0,83 po

27
Longueur de câblage : 500 mm / 19,69 pouces
Diamètre des trous de fixation : 5 mm / 0,2 pouces
Plus petite Distance entre les trous (Centre de le œil au Centre de l’oeil) : 42 mm / 1,65 pouces
Diamètre de canon : 102 mm / 4,02 pouces
Longueur du canon : 91 mm / 3,58 pouces
Numéro de modèle : UNITE ZY1016
Diamètre de l'arbre : 12 mm / 0.47 pouces
Longueur hors tout : 120 mm / 4.72 pouces
Hauteur hors tout : 110 mm / 4,33 pouces
Largeur hors tout : 115 mm / 4.53 pouces

Figure 21 : Moteur électrique

28
Conclusion

Pour conclure, nous avons effectué ce stage au sein de l’Institut des Matériaux Jean
Rouxel de Nantes dans le cadre de notre troisième année de Licence EEA. Durant ces deux
mois, nous avons pu participer à ce projet de conception d’une calèche autonome
destinée aux personnes à mobilité réduite.

D’abord, Ce stage nous a permis de découvrir ce petit ordinateur qu’est le Raspberry Pi,
ainsi de perfectionner les connaissances que nous avions dans le langage python mais
aussi d’en apprendre de nouvelles sur ce langage de programmation. Nous avons pu nous
familiariser avec l’invité de commande du Raspberry Pi.

Ensuite, dans ce stage nous nous sommes rendu compte que qu’il était intéressant de
chercher des solutions afin de répondre à une problématique.

Finalement, nous avons pu achever toutes les tâches qui nous étaient demandées et nous
sommes heureux d’avoir pu participer à ce projet, ce fut une expérience enrichissante et
qui sûrement nous encourageras à poursuivre nos études dans ce domaine qui est
l’électronique embarquée.

29
Bibliographie

 Livre de Marc-Olivier Schwartz pour la domotique

 Livre de Patrice CLEMENT pour python et RASPBERRY PI

 http://www.yahboom.net/study/4wd-Pi
 https://pypi.org/project/adafruit-circuitpython-mcp3xxx/

30