Amélioration de la machine de recyclage de matériaux pour impression 3D

Bonjour à toutes et à tous !

    Nous sommes deux étudiants en deuxième année de cycle préparatoire d’école d’ingénieur, Alan et Romane. Nous avions pour projet d’améliorer la machine de recyclage de matériaux pour impression 3D.

Contexte

    La machine de recyclage de matériaux pour impression 3D existait déjà au début de notre projet. En effet, il y a trois ans, deux élèves espagnols se sont lancés dans la création de cette machine composée de plusieurs éléments :
    • l’extrudeuse : permettant de chauffer les granulés et de faire sortir du fil
    • le système de refroidissement : constitué d’un ventilateur qui refroidit le fil dès sa sortie
    • le système de tirage : tire sur le fil
    • le système de bobinage : permettant d’obtenir une bobine de fil pour tout types d’imprimante 3D
    • le système d’alimentation : permettant de mettre en fonctionnement les deux moteurs
    • le système de mesure : permettant de mesurer le diamètre du fil instantanément

201236821_2778911395754904_3866145828310538189_n

Photo de la machine de recyclage de matériaux pour impression 3D

Objectifs :

    Nous avions pour objectif de vérifier le fonctionnement de la machine et de faire les réparations nécessaires dans un premier temps. Ensuite nous devions refaire le support du capteur pour avoir une meilleure précision sur les valeurs affichées. Pour finir, nous devions faire des modifications sur le code de la carte Arduino Uno afin d’obtenir un affichage plus précis et lisible.

Réparations :

    La machine n’ayant pas fonctionné pendant trois ans, nous avons dû faire quelques réparations dès la première mise en route. Nous avons branché plusieurs fils ainsi que fait quelques raccordements. Nous devions coller différentes pièces qui s’étaient désolidarisées avec le temps ou encore serrer des vis. Nous avons donc dû faire attention à chaque élément de la machine dès la mise en route pour ne pas passer à côté d’une modifications ou réparations à faire.

Support Capteur :

    La création d’un support pour le capteur est la partie la plus importante de notre projet. En effet, il fallait absolument créer un nouveau support car l’ancien, que nous avions en notre possession, laissait entrer beaucoup de lumières.
    Il faut savoir que notre capteur fonctionne avec une LED de couleur rouge. Dès que le fil passe entre la lumière rouge et le capteur, il y a une ombre qui se forme sur le capteur. c’est grâce à cette ombre que le capteur peut récupérer une mesure.
    Cependant, si le capteur est sujet à des perturbations telles que la lumière, il ne pourra pas fonctionner correctement et donner des résultats précis.

    Nous nous sommes documentés sur les différentes formes que peut avoir un support capteur. Nous sommes tombés sur le site suivant :

    Il nous a permis de concevoir un support de capteur qui réduit considérablement l’exposition de celui-ci à la lumière.

    Nous avons décidé de réaliser notre support de capteur en trois parties :

    • 4 pieds
    • pièce du dessous avec la place du capteur
    • pièce du dessus avec la place de la LED rouge

vu pièce

Ensemble des pièces qui constituent notre support Capteur

    Après plusieurs impressions et réglages nous avons obtenu le support de Capteur que nous voulions.

201003828_1490306371330896_6928535255193889305_n

Photo du support de Capteur final

Carte Arduino Uno :

    Nous avons fini notre projet en nous occupant de la carte Arduino Uno. Notre but était d’afficher la valeur du diamètre mesuré de façon plus claire. Pour cela nous avons étudié le code de la carte Arduino Uno. Après plusieurs recherches sur le site internet Arduino et à partir de vidéos, nous avons trouvé le problème. Il fallait enlever cette ligne du code pour que l’affichage soit directement plus clair :

ligne de trop arduino

Conclusion :

    Pour conclure nous avons réussi à refaire fonctionner cette machine de recyclage de matériaux pour impression 3D ainsi qu’à l’améliorer grâce au nouveau support de capteur et une modification du code existant afin d’obtenir un affichage du diamètre plus clair et lisible.

Photomatonsaïque : des photos en mosaïque

Galerie

Cette galerie contient 2 photos.

Bonjour à tous ! Nous sommes deux étudiants en deuxième année du cycle préparatoire de l’école d’ingénieur Polytech Angers. Dans cet article, nous allons vous parler de notre projet de conception sur lequel nous avons travaillé tout au long du … Continuer la lecture

Serious Game Innovation

    Bonjour à tous,

Nous sommes 3 étudiants de deuxième année du cycle préparatoire à Polytech Angers : Théo, Basile et Simon. Lors de notre dernier semestre, nous avons eu l’opportunité de réaliser un projet de notre choix. Nous allons donc vous présenter notre projet de groupe « SERIOUS GAME INNOVATION ». Nous devions créer un jeu ludique tout en apportant les éléments nécessaires à la compréhension et à l’apprentissage de certains procédés d’innovation. Le but du jeu est de développer des innovations autour de l’automobile. A la fin c’est le joueur ayant le plus d’argent qui gagne la partie.

  • Nos objectifs

Le but de ce projet était d’allier le côté ludique et apprentissage de l’innovation dans un jeu de société. Pour ce faire, nous devions construire notre jeu autour d’une interface numérique facilitant le décompte des points ainsi que la gestion des comptes en banque. De plus, ce jeu doit pouvoir être réalisé en cours ou lors d’une formation d’entreprise sur l’innovation. Le cahier des charges nous proposant plusieurs contraintes comme la durée du jeu ou le matériel nécessaire, nous avons dû penser à des solutions, celles-ci devant être les meilleurs pour permettre une bonne immersion des joueurs dans le jeu.

  • Découverte, documentation et analyse fonctionnelle

Cette partie nous a permis d’appréhender le sujet et de clarifier les objectifs. Nous avons découvert notre cahier des charges, puis nous nous sommes renseignés sur les Serious Game existants sur le marché. Cela nous a permis de mieux visualiser le jeu à réaliser.
Ensuite, nous avons débuté la partie analyse fonctionnelle indispensable dans notre projet. Celle-ci avait pour objectif de déterminer avec objectivité les fonctions que devait satisfaire notre produit afin de valider le cahier des charges. Certaines fonctions étaient imposées par le cahier des charges comme la cible du jeu, tandis que d’autres comme le matériel étaient plus libres. Cette partie nous permis d’identifier certains points forts et failles du projet, et donc de travailler dessus par la suite pour apporter une amélioration, ou une atténuation d’une contrainte.

  • Développement et conception

Cette partie est sûrement la plus intéressante et la plus longue du projet. Tout d’abord, nous allons vous parler de notre application, qui est l’outil principal de notre jeu. Après de longues réflexions et essais, nous avons décidé de la programmer en langage C. Ce langage nous a permis d’avoir une plus grande liberté de création ainsi qu’une certaine fiabilité permettant la gestion bancaire de la partie. C’est sans aucun doute ce qui nous a pris le plus de temps surtout par son côté expérimental. Nous avons fait évoluer notre programme au fur et à mesure du projet, ce qui nous a permis d’y intégrer par exemple le plateau de jeu en version numérique (c’est-à-dire les données concernant les cartes et les différents événements). Notre application regroupe :

    – L’interface et la fiche des joueur
    – Un système de comptage de points
    – Une gestion bancaire pour les joueurs avec notamment une fonctionnalité de prêt bancaire
    – Une banque de donnée comportant les éléments physiques du jeu
    – La possibilité d’acheter certaines ressources
    – Un système de gestion du temps et du nombre de tours

Interface de l'application avec les différentes possibilités

Interface de l’application avec les différentes possibilités

Dans un second temps, nous avons travaillé sur la création de différents procédés de jeu comme les cartes innovation, les cases évènements, et tous les aspects « sérieux » en lien avec l’innovation. Tout d’abord les éléments sérieux de notre jeu doivent permettre la compréhension et l’apprentissage de certains procédés d’innovation. Pour une bonne jouabilité, les cartes ont été conçues de manière physique, celles-ci regroupent les informations nécessaires au développement. On y trouve par exemple le prix de lancement, la rentabilité, les employés nécessaires et enfin des phrases reprenant certains concepts de l’innovation mais aussi des faits marquants liés à l’innovation automobile.

Pour améliorer le réalisme du jeu, nous avons pris en compte l’aspect de la concurrence en classant les innovations dans différentes catégories. Par exemple, si plusieurs joueurs développent des innovations d’une même catégorie ils devront se partager le marché et donc leurs bénéfices seront réduits. L’application se charge donc de diminuer automatiquement le gain des joueurs si leurs innovations appartiennent au même secteur.

La répartition des innovations pour créer de la concurrence

Répartition des innovations dans le système de concurrence

Ensuite, le plateau est un aspect important du jeu. Il est constitué de cases “évènements” qui ont pour but de représenter les aléas dans les entreprises. Nous avons décidé de créer un design liant le côté ludique avec le thème de l’automobile, notre choix s’est donc porté vers le célèbre jeu vidéo Mario Kart, qui nous permettait de pouvoir inclure nos cases évènements sur le tracé du « circuit Yoshi ».

Plateau de jeu

Plateau de jeu

  • Conception du matériel en 3D et en bois

Pour compléter le projet et acquérir de nouvelles compétences, nous avons conçu des pièces sur SolidWorks pour ensuite les imprimer en 3D. Pour rester dans le thème de l’automobile, nous avons choisi des pions représentant des véhicules.

Les 4 pions appartenant chacun à un joueur

Les 4 pions appartenant chacun à un joueur

Puis, d’autres pièces ont été conçus et imprimés dans le but d’améliorer l’expérience de jeu : une boite pour la pioche des cartes innovations et une roulette permettant au joueur d’avancer son pion sur le plateau. A chaque tour le joueur lance la roulette et il pourra avancer son pion de 1,2,3 ou 4 cases. Nous avons choisi de concevoir une roulette plutôt qu’un dé pour éviter les « 5 » et « 6 » et ainsi empêcher qu’un joueur finisse le tour trop rapidement. Cela apporte également de l’originalité au jeu.

La flèche qui désignera la case sur le socle.

La flèche qui désignera la case sur le socle.

Le socle de la roulette permettant aux joueurs de savoir le nombre de cases à parcourir.

Le socle de la roulette permettant aux joueurs de savoir le nombre de cases à parcourir.

Le support de pioche qui permet de stocker les cartes innovations.

Le support de pioche qui permet de stocker les cartes innovations.

  • La boîte de rangement

Pour pouvoir ranger et transporter le jeu, nous avions conçu une boite de rangement en 3D pouvant accueillir tous les éléments du jeu comme cela était requis par le cahier des charges. Dans l’objectif de réduire au maximum le volume de la boite, nous avons créé une ergonomie spéciale de la boite.

Boite de rangement pouvant contenir tous les éléments du jeu.

Boite de rangement pouvant contenir tous les éléments du jeu.

Cependant, nous avons eu des difficultés à imprimer la boite en termes de durée d’impression et à cause de la chaleur : le fil sortant de la buse ne se solidifiait pas assez rapidement pour obtenir un résultat correct. Nous avons donc décidé de la fabriquer en bois avec les moyens du FABLAB de l’école. Le résultat et tout aussi correct et permet bien de ranger et de transporter tout le jeu.

Boîte de rangement en bois

Boîte de rangement en bois

  • Conclusion

En conclusion, nous sommes très heureux du résultat obtenu. Nous avons apprécié travailler sur ce projet. Notre jeu fonctionne très bien. Il est à la fois ludique et sérieux comme nous le demande le cahier des charges. Nous sommes également fiers du système automatique et digital de comptage des points et de gestion que nous avons programmé pour améliorer l’expérience des joueurs. Enfin ce projet nous a permis d’apprendre à utiliser SolidWorks ainsi que l’imprimante 3D car nous n’avions pas eu l’occasion de le faire en première année à cause des conditions sanitaires.

Pour finir, ce projet est une réussite collective pour tous les 3 car nous avons su apprendre, travailler en autonomie et développer des compétences spécifiques qui seront indispensables dans notre future vie professionnelle.

Jeu complet

Jeu complet


Roulette imprimée en 3D

Roulette imprimée en 3D


Support de pioche imprimée

Support de pioche imprimée

Merci de votre lecture

Galinier Simon, Moissonnier Théo, Perly Basile

Création d’un mur de lumières pour Escape Polytech

Bonjour à toutes et à tous ! Nous sommes trois étudiants de 2ème année actuellement en fin de cycle préparatoire de Polytech Angers et nous allons vous présenter notre projet réalisé plus tôt dans l’année : Le Mur-Lumières.


CAO

Rendu 3D de notre mur lumière

Nous avons utilisé des outils de CAO pour perfectionné le design de l’ensemble et éviter les erreurs de conceptions.

Programmmation

Une petit partie du code de notre projet

Un script python permet de contrôler le comportement de l’ensemble des élements.

Assemblage

Assemblage de la machine

Pour concrétiser le projet nous avons réalisé la fabrication de tout le bâti et le câblage nécessaire au bon fonctionnement.


Introduction de notre projet :

Vue générale du Mur Lumières

Ce projet fait partie d’un lot de projets associés à l’escape Polytech, un escape-game réalisé par les enseignants chercheurs de Polytech qui ont décidés de demander de l’aide aux étudiants pour créer des mini-jeux futurs. Le nôtre consiste à reproduire une forme sur un écran d’ampoules Philips HUE 5×5 à l’aide de boutons qui pilotent les ampoules : à vous de trouver la bonne combinaison !

Création du bâti :

Dans notre projet, il nous a fallu créer un bâti pour pouvoir stocker tous les autres composants et déplacer le tout facilement. Ainsi, l’utilisation de SolidWorks nous a paru nécessaire pour créer ce que nous avons choisi de faire : une borne d’arcade. Cette partie du projet n’a pas été la plus longue du fait que le bâti était plutôt simple à réaliser.
Cette CAO a ensuite permis la découpe puis l’assemblage des pièces dans du bois acheté chez un de nos fournisseurs.

Création du programme gérant les Ampoules Philips :

Pour contrôler les ampoules connectées, nous avons utiliser un pont Philips Hue se connecte aux ampoules avec le protocole ZigBee. Aussi, les 16 boutons que nous avons utiliser requièrent une carte PacLed 64 pour changer leurs couleurs simplement. Pour faire fonctionné tout les composants électronique ensemble nous avons utiliser un script python sur un Raspberry Pi 4. Ce programme permet de contrôler le clavier à l’aide d’un Arduino Uno, l’écran LCD, le pont, les boutons de couleurs avec la PacLed. Le code est pensé pour être le plus modulable et évolutif possible. Nous avons fait attention à ce que le code permette une grande résilience face aux éventuels petites interférences et perturbations qui pourrait survenir à cause de l’utilisation de fils non isolé pour transmettre de l’information entre les composants.

Assemblage et Tests réalisés à Polytech :

Une fois toute la partie programmation terminée, nous avons pu amener les planches découpées à Polytech pour y faire l’assemblage. Par la suite, nous nous sommes occupés de la longue partie concernant le branchement des multiples câbles (électriques et électroniques) avant de relier les cartes Arduino et Raspberry à nos autres composants.
Malgré quelques heures de complications à performer le code pour satisfaire toutes les conditions souhaitées, nous sommes arrivés à terminer le projet en temps et en heure !

Vue arrière du boîtier ouvert

Vue arrière du boîtier ouvert

Déroulement d’une partie :

Une partie peut donc se dérouler de la façon suivante :
– Le joueur arrive et sélectionne son niveau à l’aide du clavier qui lui confirme par la suite grâce au LCD

Ampoules de toutes les couleurs
panneau de commandes avec les boutons de couleurs

– Il essaye de trouver la bonne combinaison de boutons pour avancer dans le jeu et parvenir à trouver le résultat désiré
– Lorsqu’il trouve, un code s’affiche sur l’écran LCD et le joueur peut passer au niveau suivant.

Conclusion :

Grâce à l’importance de la communication et du travail d’équipe au sein de notre groupe, nous avons pu répondre à un cahier des charges qui semblait impossible si l’on s’y attaquait seul. Ce projet nous a d’autre part permis de développer nos compétences en CAO, en programmation et surtout nous a offert des connaissances en matière d’électricité, de moyens d’assemblages et sur bien d’autres domaines. Nous tenons à remercier encore une fois toutes les personnes ayant contribué au projet et nous espérons que ce projet, dont nous avons pris beaucoup de plaisir à réaliser, sera amené à être améliorer les prochaines années.

Caméra pour robot KUKA KRC3

image1

Fixer une caméra à un bras robot. Qu’est-ce que pourrait mal se passer?

Nous sommes Théotime Aubin et Antoine Grimault, notre objectif a été de fixer une webcam au bras robot KUKA et de lui faire détecter des objets sur un plan (fixe) défini au préalable.
La première étape a été de choisir l’emplacement de la webcam.

image2

  • On aurait pu choisir de fixer la caméra dans l’espace de travail du robot.
  • image3

  • Il était aussi possible de la fixer sur le côté du robot, et d’avoir une position de prise de vue différente de la position d’action.
  • image4

  • Enfin, on pouvait fixer la caméra directement sur la flasque du bras, avant l’outil.
  • Nous avons choisi la dernière option car ce système limite faiblement les mouvements du bras,
    et le repère de la caméra est “simple” à définir par rapport au repère de la flasque. C’est aussi plus facile de la fixer solidement ici.
    Il est possible que l’outil soit visible sur l’image, cela pourrait poser problème pour la détection des objets, mais d’après nos mesures cela a peu de chances d’arriver.

    Une fois ce choix fait, nous avons démonté la webcam pour n’en garder que l’électronique (PCB), puis modélisé un boitier sur SolidWorks que nous avons ensuite imprimé en 3D.

    Capture5
    Capture2


    Capture1
    Capture4


    Capture

  • Vient ensuite la phase deux… le traitement d’image :

  • Pour ceci nous avons décidé d’utiliser Python avec le module OpenCV sur un ordinateur séparé du robot. On a codé une application qui permet à l’utilisateur du robot d’avoir un retour vidéo pour calibrer la ‘‘visée’’, fait une détection de contour et donne les coordonnées d’un objet situé sur l’espace de travail défini au préalable, en convertissant au passage des pixels en millimètres.

    nnwn
    Capture6

  • Vient ensuite la phase trois… la programmation du robot :


  • Capture10

    Le but est simple. Le robot est capable de connaitre en temps réel la position de la flasque. Notre travail dans ce programme est de donner au robot les translations et rotations de repère afin de disposer des coordonner de la caméra en temps réel.

    Capture720210604_184736

    Après s’être bien creusé les méninges on finit par comprendre et ça donne un beau petit programme :



    Capture8

  • Conclusion :
  • Quand on fait tout fonctionner ensemble le robot est capable de localiser une pièce, en déduire ses coordonnées et la pointer. il aurait été possible d’aller un peu plus loin en communiquant directement les coordonnées au robot via une carte d’entrée sortie utilisant le protocole TCP/IP, mais celle ci a mis trop de temps a arriver.

    Capture9

    Projet Chorduino

    Introduction :

    Bonjour, nous sommes Pierre PORTRON et Yohann CONANEC, tous les deux étudiants en PEIP2-A à Polytech Angers.

    Le but de ce projet était de créer un système permettant d’accompagner un musicien en jouant une série d’accords sur un synthétiseur. Pour cela nous avions à notre disposition une carte Arduino UNO, muni de boutons poussoirs et d’un écran LCD, une pédale, un câble MIDI-USB et un câble Arduino-USB

    Travail réalisé :

    1-Le codage des accords :

    Un accord est un ensemble de notes joué simultanément, ils sont définis par le type d’accords ainsi que la note fondamentale, qui est la première note jouée.

    Pour coder les types d’accords nous créons un tableau pour chaque type, contenant dans l’ordre, le nombre de notes, l’écart entre les prochaines notes et la note fondamentale.

    tab acc

    Afin de coder l’accord en lui-même nous avons numéroté chaque notes de 0 à 11 et chaque types d’accords de 0 à 19 que l’on multipliait par 12.
    pour chaque accords on additionne la valeure de la note fondamentale et du type d’accord

    exemple : type accord n7 : 2 * 12 = 24
    note fondamentale D : 5
    accords = 24 + 5 = 29

    image_2021-06-16_165859

    Afin de décoder l’accord lorsque l’on souhaite le jouer on trouve la note fondamentale en appliquant un modulo 12 à la valeur de l’accord et ont la divise par 12 pour trouver le type d’accord

    Exemple :
    Accords = 29
    Note fondamentale= 29 % 12 = 5 = D
    Type d’accord = 29 / 12 = 2 = n7

    image_2021-06-16_170010

    2-Jouer l’accord :

    Pour jouer l’accord on le décode comme vu précédemment pour obtenir le type d’accord et la note fondamentale. Puis on utilise la fonction MIDI.sendNoteOn(note, volume) en additionnant à chaque fois la note fondamentale de la valeur noté dans le tableau du type d’accord.

    image_2021-06-16_171125

    3-Les grilles d’accords

    Les grilles d’accords sont des tableaux d’accords ce qui nous permet de jouer plusieurs accords à la suite.

    grille

    Pour cela on regarde la valeur envoyée par la pédale (plus on appuie plus la valeur augmente)
    Lorsque cette valeur dépasse 400 on joue le premier accord puis quand on la relâche on passe à l’accord suivant.

    jouergrille

    4-La liaison série

    Pour entrer une grille manuellement, on utilise la liaison série Arduino présent sur l’IDE Arduino. On reçoit la nouvelle grille sous forme d’une chaîne de caractères que l’on transforme en un tableau d’entiers représentant les accords.

    image_2021-06-16_173809

    moniteur

    Vidéos montrant le projet en fonctionnement :

    drive.google.com/file/d/1ohHWEjFQPqnQ6lgYgXIuU3x8RuiLttEy/view?usp=sharing
    https://drive.google.com/file/d/1pDgMJ5z21NYXAhiWjoK8Dx4-1u30MCZR/view?usp=sharing
    https://drive.google.com/file/d/1osvTKHlHw0p1z_huiWoCOzXzyjFL0QGX/view?usp=sharing

    Conclusion :

    Ce projet nous aura finalement beaucoup apporté, notamment au niveau du travail de groupe sur un projet de cette durée.

    Nous sommes très fiers du résultat même si plusieurs points pourraient être améliorés.

    Merci beaucoup à M COTTENCEAU pour son aide.

    Projet voiture RC roues 180°

    Introduction :

    Bonjour à tous, nous sommes Tony Barbier, Jean Nobel et Errol Sistach, tous trois étudiants en deuxième année à Polytech Angers.
    Dans le cadre de notre formation, nous sommes amenés à réaliser un projet. Le notre était la conception d’une voiture radiocommandée dont la particularité est la rotation de ses roues sur 180°.

    Nous avons choisi ce projet car il est complet, il nous a permis de toucher à plusieurs domaines différents : la CAO, la mécanique, la programmation et l’électronique.
    Les différentes étapes de notre projet ont été la modélisation, la programmation et finalement l’usinage de notre voiture.

    Travail réalisé :

    Présentation de la modélisation :

    Châssis
    Tout d’abord le châssis. Sur les parties gauches et droites, l’enlèvement de matière sur l’axe horizontal est fait pour laisser passer les servomoteurs. Les deux renfoncements moins profonds sont prévus pour les boulons de serrage lorsque les roues seront soit à 90° à droite soit 90° à gauche.
    Les trous sur les parties haute et basse sont faits pour laisser passer les roues quand elles seront complètement tournées.

    Essieu avant
    Voici l’essieu avant. Les deux essieux sont sensiblement identiques, la seule différence est qu’il n’y a pas de motoréducteurs (en jaune) à l’arrière.
    Chaque essieu est composé d’une barre et de deux équerres. Pour pouvoir tourner, le palonnier (l’hélice) du servomoteur est relié à la barre, les essieux seront alors dirigés à gauche ou à droite selon la direction où l’on veut aller.

    essieu vue dessus 1essieu vu dessus 2

    Pour finir cette partie, les roues arrières seront maintenues grâce à des carrés de fixation. Pour les roues avant, les motoréducteurs servent aussi d’arbres. carré de fixationfixation motoréducteurs

    Réception et test des composants :

    Arduinomotoréducteurservomoteur

    Après avoir réceptionné ces composants, nous avons branché les servomoteurs et les motoréducteurs à la carte Arduino, et nous avons tout alimenté avec une batterie pour vérifier leur bon état de fonctionnement.

    Programmation :

    Grâce aux bibliothèques AFMotor, Servo et SoftwareSerial il a été très facile de créer un programme pour piloter les moteurs. Il suffisait d’indiquer les pins sur lesquels les moteurs étaient fixés puis d’utiliser les fonctions incluses dans les bibliothèques pour les mettre en mouvement.

    téléphone
    Grâce au site Mit App Inventor nous avons créé une application Bluetooth Android qui communique avec le module Bluetooth HC-06 et donc pilote la voiture. L’application est constituée d’une interface utilisateur pour se connecter au module Bluetooth puis faire avancer/reculer et tourner la voiture. La partie programmation est intuitive et se fait à l’aide de blocs. Lorsque l’utilisateur appuie sur un bouton, l’application envoie un ordre (par exemple « l » en ASCII pour « left ») et le module Bluetooth récupère cet ordre pour le transmettre à la voiture.

    Mais la façon la plus simple de piloter la voiture reste celle sur ordinateur en utilisant le port USB de l’Arduino. Nous avons donc utilisé l’IDE Processing pour développer un programme permettant à l’utilisateur de communiquer avec la carte par l’intermédiaire d’un port USB.

    Usinage :

    Notre voiture est faite à partir d’une plaque en bois de 5mm d’épaisseur. Nous avons utilisé la fraiseuse du Fablab de Polytech Angers pour usiner chacune des pièces nécessaires à la réalisation de la voiture.

    Nous avons ensuite montés les pièces entres elles : usinage 1

    Puis nous avons soudé des fils électriques entre les motoréducteurs et la carte Arduino. Et pour finir, nous avons relié le palonnier de chaque servomoteur aux essieux respectifs.

    Conclusion :

    Ce projet nous aura été très formateur. C’était vraiment intéressant de se tourner vers quelque chose de plus concret.
    C’est toujours une bonne expérience de travailler en équipe, d’autant plus lorsque c’est un projet comme cela.
    Malheureusement, notre voiture était loin d’être parfaite mais nous sommes quand même fier du travail fourni et du résultat.

    Merci à M. Verron pour toute son aide.

    Tony Barbier, Jean Nobel, Errol Sistach.

    Cryptographie Visuelle

    Nous sommes deux étudiants en peip2A à Polytech Angers, Baptiste Marchand et Clément Veyer. Cet article vous présente notre projet de cryptographie visuelle. Ce projet s’est effectué dans le cadre des projets de fin de cycle préparatoire aux écoles Polytech. Nous avons choisi ce projet car, tous deux, nous voulons poursuivre nos études d’ingénieur dans le domaine informatique, et ce projet s’inscrit parfaitement dans notre démarche.

    La cryptographie visuelle, qu’est-ce que c’est?
    La cryptographie visuelle est l’art de protéger des messages sous formes d’images. On obtient alors des “masques” qui sont en fait des images en noir et blanc générées aléatoirement. La méthode a été créée par Moni Naor et Adi Shamir en 1994, deux chercheurs en mathématiques et informatique. Ce qu’il y a de tout à fait particulier avec ce concept, c’est qu’il est à la fois accessible à tout le monde car très visuel, mais paradoxalement quasi impossible à cracker sans disposer de tous les masques nécessaires.

    Image 1 : exemple de cryptographie visuelle avec deux masques jetables

    Image 1 : exemple de cryptographie visuelle avec deux masques jetables

    Présentation du projet
    Le but de ce projet était à la base très simple : créer un programme python permettant d’effectuer une cryptographie visuelle à partir d’une image que l’on veut cacher. Dans notre groupe, nous nous sommes fixés plusieurs objectifs qui découlent du premier. Dans un premier temps, la création d’une GUI (Graphic User Interface) qui regrouperait l’ensemble des méthodes que nous avons pu mettre au point. Mais également, sur l’idée de Sébastien Lagrange, nous nous sommes fixés l’objectif de créer un jeu de cartes classique (32 cartes) qui permettrait de révéler un symbole différent pour chaque combinaison de carte, soit (31*32)/2 = 496 combinaisons différentes.

    Méthode basique des masques jetables
    Cette méthode est l’essence même de toutes les autres. Elle prend une image en noir et blanc, constitué donc de 0 et de 1 et la divise en 2 images distinctes. La première des deux images est générée complètement aléatoirement. La seconde, est générée en fonction du masque et de l’image d’origine. Pour faire le choix de couleur de de cette image, on utilise un XOR. Si on applique de nouveau un XOR aux images chiffrées, on retrouve l’image secrète à la perfection. Et si l’on superpose physiquement les 2 images (OU), on retrouve l’image secrète, mais imparfaite car cette fois-ci elle possède du bruit, comme illustré sur l’Image 1.

    Pour faire notre premier programme qui appliquait donc cette méthode, voici les étapes que nous avons suivi sur python, à l’aide du module Pillow :
    • on demande à l’utilisateur l’image à crypter (qui doit être purement en noir et blanc)
    • on ouvre le fichier (png ou jpg) et on en fait une matrice de pixels de valeurs 0 ou 255
    • on crée un premier masque aléatoirement (donc 50% noir et 50% blanc)
    • on crée le second masque, en faisant pour chaque pixel, un xor entre le pixel original, et celui du premier masque
    • on enregistre les deux masques, et le tour est joué!

    Améliorations
    Cette première méthode fonctionne très bien, mais après l’avoir terminée, nous avons vite compris le potentiel de cryptographie visuelle. On pourrait par exemple réduire le bruit, augmenter le nombre de masques, ou encore avoir des masques imagés.
    Mais pour faire tout cela, il faut quadrupler la taille des masques créés. On a ainsi, pour chaque pixel original, une matrice de 2*2 pixels.
    Nous pouvons donc nous permettre de représenter les pixels par des niveau de gris. Tel que: noir 0% = 0 pixels noir sur les 4, 25% = 1 pixel noir sur les 4, 50% = 2/4 , 75% = 3/4, 100% = 4/4.
    Si on reprend la première méthode avec la taille quadruplée, on obtient les cas suivants :

    Image 2 : différentes combinaisons pour chaque pixel original en ayant quadruplé la taille des masques

    Image 2 : différentes combinaisons pour chaque pixel original en ayant quadruplé la taille des masques

    Les combinaisons en haut de l’image décrivent un pixel original blanc, et celles d’en bas décrivent un pixel original noir. On aura, en superposant les masques, un blanc qui est en fait un gris 50%, et un noir 100%.

    Une fois qu’on a fait cela, on imagine aisément que, si on veut maintenant trois masques, on aura un résultat avec un blanc 75%. En effet, on superpose trois matrices de 2*2 pixels qui laissent passer un seul pixel blanc.

    Avec cette nouvelle méthode, la taille quadruplée réduit le bruit observé par l’oeil humain, et les trois masques permettent une sécurité de plus : si on superpose 2 des 3 masques, on n’observe rien du tout à part du gris. Voici le résultat qu’on obtient :

    Image 3 : Exemple de cryptographie visuelle à trois masques

    Image 3 : Exemple de cryptographie visuelle à trois masques

    Méthode des masques imagés
    Cette méthode est la plus convaincante de toutes, car les masques ont maintenant un sens. Il faut donc 3 images pour cette méthode, 2 images seront visibles et la 3ème secrète, cachée dans les deux autres. Pour ce faire, on utilise bien sûr les masques à taille quadruplée.

    Les masques ont des pixels blancs représentés en 50% et des pixels noirs en 75%.
    L’image obtenue par la superposition (OU) des deux masques imagés, elle possède des pixels blancs en 75% et des pixels noirs en 100%.

    A partir d’ici, on distingue 8 possibilités distinctes:
    4 possibilités ou le pixel secret est blanc, donc un pixel 75% obtenu une fois superposé
    Le premier masque est blanc, le second aussi
    Le premier masque est noir, le second aussi
    Le premier masque est blanc, le second noir
    Le premier masque est noir, le second est blanc (équivalent au précédent)

    Et 4 autres ou le pixel secret est noir, donc un pixel 100%, obtenu une fois superposé:
    Le premier masque est blanc, le second aussi
    Le premier masque est noir, le second aussi
    Le premier masque est blanc, le second noir
    Le premier masque est noir, le second est blanc (équivalent au précédent)

    Nous avons décomposé les différentes configurations de pixel que nous avons choisi dans le tableau blanc ci-contre (en haut):
    Microsoft whiteboard
    Mais le plus important est de comprendre la logique:
    Lorsqu’un pixel à coder est noir, on fait en sorte de ne pas superposer les pixel noirs des masques pour qu’une fois les masques superposé, il ne reste pas de pixel blanc (noir 100%).
    Au contraire, si le pixel a coder est blanc, on fait en sorte de superposer les pixels noirs des masques pour que lorsque l’on superpose les masques, un des 4 pixels reste blanc (noir 75%).
    L’œil humain est aisément capable de faire la distinction entre du noir 75% et du noir 100%. Ce qui lui permet donc de percevoir cette image obtenue, comme vous pouvez en faire l’expérience ci-dessous.

    Image 4 : exemple de cryptographie visuelle avec deux masques imagés

    Image 4 : exemple de cryptographie visuelle avec deux masques imagés

    Pour terminer
    Pour finir, nous avons d’une part créé une interface graphique qui regroupe toutes les méthodes développées. Télechargez le dossier contenant un exécutable ci-dessous :
    Et dont voici un tuto d’utilisation : https://youtu.be/8tiozFkfo8A

    Et d’autre part, nous avons élaboré un jeu de 32 cartes sur la base des masques imagés, mais où chaque combinaison de cartes fait apparaitre une symbole différent (voir notre gitlab) .

    Nous avons voulu terminer en beauté en développant un algorithme de VSS (Visual Secret Sharing) qui permet de générer n masques, puis en superposant superposant au moins k parmi ces n masques, nous pourrions observer l’image secrète. Malheureusement, nous avons à peine eu le temps de finir notre travail de recherche à ce sujet.
    Pour avoir plus de précisions sur ces trois projets, nous vous conseillons également de télécharger notre rapport complet, disponible à la fin de cet article.

    Conclusion
    Pour conclure, ce projet nous a permis d’abord de mettre en application nos connaissances en terme d’algorithmique et d’adaptation à un langage de programmation. Effectivement, nous n’avions encore jamais vraiment programmé en python, et nous avons réussi assez rapidement à nous accommoder au langage qui a l’avantage d’être facile à appréhender.
    Nous avons également eu l’occasion de faire un travail de documentation important pour essayer de bien comprendre tous les concepts, même si nous n’avons pas eu l’occasion de tout mettre en application. Pour cela, nous avons exploité de nombreux articles de recherche, notamment ceux de Moni Naor et Adi Shamir, mais également des articles français. Cela nous a permis d’effectuer un “semblant” de travail de recherche assez intéressant.
    Finalement, nous sommes fier du travail que nous avons produit et avons accompli nos 2 objectifs principaux. Avec plus de temps, nous aurions pu essayer de développer la méthode ultime de VSS.

    Télécharger le rapport de notre projet :

    Projet LoRa

    Bonjour à tous ! Nous sommes deux étudiants en deuxième année de PeiP à Polytech Angers, Marius LESAULNIER et Maël COCHET. Notre projet a pour but d’utiliser la technologie LoRa (Long Range) qui est une technologie qui permet d’envoyer des données à grande distance afin de détecter une intrusion dans un bâtiment, par exemple un garage.

    Contexte :

    lora vs sigfox

    L’internet des objets (IoT) est un marché en plein essor et plusieurs rapports d’experts annoncent que dans les prochaines années, il y aura plusieurs dizaines de milliards d’objets connectés dans le monde.
    Il existe différents réseaux permettant de rendre les objets communicants. Ce sont des réseaux innovants car ils ne sont pas basés sur les technologies cellulaires. Ils sont dédiés à l’IoT (Internet of Things), ce sont les réseaux LPWA : Low Power Wide Area (réseau bas débit longue portée).
    Il existe aujourd’hui deux principaux concurrents sur ce marché : Sigfox et LoRa. Sigfox est un réseau privé. LoRa quant à lui est un réseau ouvert et public. Les entreprises qui le souhaitent peuvent donc créer leur propre réseau et l’exploiter.

    Le matériel et logiciels utilisés :

    Nous avons utilisé une carte arduino MKR 1300 WAN qui est équipée d’une puce LoRa, ce qui nous sera utile pour envoyer les données d’un capteur vers le réseau LoRaWAN “The Things Network”.

    Carte arduino et son antenne

    Carte arduino et son antenne

    Pour envoyer les données de la carte au réseau LoRa, celle-ci doit passer les données par un gateway, c’est là qu’intervient le gateway Kerlink iFemtoCell. Ce gateway sert de passerelle pour permettre une communication bidirectionnelle pour un réseau Lora privé.

    Gateway Kerlink iFemtoCell

    Gateway Kerlink iFemtoCell

    Les capteurs utilisés pour relever les différents états d’un évènement sont simplement des capteurs de contact / magnétiques qui envoient des données binaires (ouvert / fermé) correspondant à la situation.

    Le capteur magnétique que nous avons utilisé

    Le capteur magnétique que nous avons utilisé

    Nous avons aussi utilisé l’application Arduino afin de programmer notre carte et lui indiquer les données à envoyer sur le réseau. Ensuite nous avons fait le choix de travailler sur le site web The Things Network (https://www.thethingsnetwork.org/) qui est un réseau Lora WAN communautaire et open source pour l’Internet des Objets (IoT en anglais). Actuellement le réseau se compose de plus de 40000 contributeurs regroupés en plus de 400 communautés dans 90 pays ayant déployé plus de 4000 passerelles. Ce site est la référence actuelle quand on veut créer un réseau Lora WAN, et exploiter les données de celui-ci. Notre choix s’est donc naturellement tourné vers ce site.
    Afin de transmettre les différentes informations envoyées sur le réseau et les transmettre ensuite à différentes applications (mail, message, etc), nous avons utilisé le site IFTT (https://ifttt.com/), et les webhooks (aussi appelé lien de rappel HTTP qui est en programmation Web une méthode permettant de modifier le comportement d’une page Web ou d’une application (whats-webhook/).

    Après ces quelques explications, passons à la réalisation du projet !

    Déroulement du projet :

    Tout d’abord, nous devons configurer le gateway et le connecter au réseau. Pour cela, nous avons recherché et lu beaucoup de documentations sur ce gateway mais sans pour autant arriver à ce que cela fonctionne. On a donc décidé de contacter le support technique du magasin qui nous avait vendu le gateway et il nous a été d’une grande aide. Grace à la documentation plus spécifique que le technicien nous a envoyée et de ses conseils, nous avons pu configurer le gateway et le mettre à jour comme on vous le montre dans la vidéo tutorielle juste en dessous :

    Configuration du gateway et mise à jour

    Vidéo de la configuration du gateway et mise à jour

    Une fois le gateway connecté et mis à jour, nous avons pu paramétrer la carte Arduino MKR 1300 WAN pour transmettre des données sur TTN (The Things Network). Pour cela, nous nous sommes aidés de tutoriels et de documentations (tutoriel de connexion de la carte arduino sur TTN). Voici ci-dessous notre vidéo tutorielle pour connecter sa carte sur TTN et envoyer un message sur TTN.

    Configuration Carte Arduino MKR  WAN 1300

    Vidéo de la configuration de la Carte Arduino MKR WAN 1300

    Après avoir réussi à envoyer des données sur TTN, il nous a fallu modifier le script Arduino pour pouvoir récupérer les données du capteur. Pour ne pas envoyer des données tout le temps sur TTN car cela est limité (le but n’étant pas d’envoyer un flux de données constant), nous avons choisi de n’envoyer des données que lorsque dans notre cas : l’état du capteur magnétique passe de 1 (porte fermée donc contact) à 0 (porte ouverte). L’envoi de données est donc unique (un par ouverture de porte).
    Maintenant que les données sont envoyées avec succès sur TTN, nous devons les récupérer pour les transmettre à nos appareils. C’est cette partie du projet qui nous a demandée le plus de temps. En effet, n’étant pas habitués à utiliser TTN, nous avons eu beaucoup de mal à trouver la bonne intégration à utiliser pour pouvoir transférer nos données à notre téléphone. De plus, tous les tutoriels que nous trouvions sur internet n’étaient plus valables car juste au moment de notre projet, TTN passait de sa version V2 à V3 et donc il n’existait pas de nouveau tutoriel ou document expliquant comment fonctionnait la version V3. Mais nous avons eu la chance que la communauté TTN soit très active et ils ont donc pu nous guider pour résoudre ce problème en nous conseillant d’utiliser IFTTT. Nous nous sommes donc penchés sur cette méthode et avons réussi à transmettre nos données. Voici ci-dessous la vidéo tutorielle de cette configuration.

    Configuration de IFTTT sur TTN

    Vidéo de la configuration de IFTTT sur TTN

    Application concrète de notre projet :

    Pour finir, une fois toute les étapes réalisées, (envoi de l’information du capteur à TTN via un gateway puis envoi de cette information sur notre téléphone via IFTTT) nous avons pu tester notre système. Pour cela, nous avons fixé un aimant sur une porte et un capteur magnétique sur le mur pour pouvoir détecter l’ouverture de cette porte. Voici ci-dessous la vidéo qui illustre notre expérimentation :

    Mise en situation du projet avec l'ouverture d'une porte

    Mise en situation du projet avec l’ouverture d’une porte

    Comme vous avez pu le voir, je reçois bien une notification à l’ouverture de la porte. L’avantage de IFTTT est que l’on peut choisir sous quelle forme on veut envoyer la notification car on peut aussi très bien envoyer un mail ou même imaginer un journal enregistrant les ouvertures de la porte sur google sheet (avec à chaque ouverture la date et l’heure).

    Pour terminer cette présentation, on vous propose un Quizz sur la technologie LoRa qui vous permettra d’en savoir plus sur cette innovation.

    QUIZZ_LORA

    Conclusion :

    Ce projet nous a permis de travailler en autonomie, mais également de chercher les informations nécessaires à l’avancement du projet par nous-mêmes, notamment grâce à Internet et divers forums.
    On a également pu comprendre la notion de Internet of Things. Avec l’essor des objets connectés cette technologie et ces applications ont de grande chance de se développer de plus en plus dans les années à venir.
    Ce projet a été l’occasion pour nous d’utiliser différents outils liés à la technologie LoRa et IoT, tels que The Things Network, My devices Cayenne, Arduino, IFTTT, etc…
    Nous tenons à remercier Mr Bouljroufi Hassan pour sa disponibilité et sa bienveillance tout au long de ce projet.

    Merci pour l’intérêt porté à notre projet
    Maël COCHET
    Marius LESAULNIER

    TUTO : Concevoir un système de surveillance

    Bienvenue à toi humble visiteur ! Besoin de protéger ta maison ? Tu as frappé à la bonne porte !

    Ici nous allons t’apprendre comment concevoir ta propre alarme de A à Z. Tout d’abord, une petite présentation s’impose : nous sommes Coline et Léa, deux étudiantes de 2ème année de l’école d’ingénieurs Polytech Angers. Dans le cadre de projet tutoré, nous avons décidé de réaliser celui encadré par Mme TIDRIRI et M. CHATTI.

    Prépare-toi, nous allons débuter !

    Système de surveillance

    Le but de notre projet consiste à concevoir, fabriquer et programmer un système de surveillance. Voici comment il fonctionne :

    L’utilisateur place le système dans l’entrée de sa maison à hauteur d’épaule. Quand il sort de chez lui, pour aller au travail par exemple, il active le système de surveillance en entrant son code secret. Si un intrus pénètre par effraction dans la maison, le détecteur ultrasons envoie un signal au système qui déclenche l’alarme. Pour arrêter la sonnerie de l’alarme, l’utilisateur doit rentrer de nouveau son mot de passe.

    De plus, notre système permet à l’utilisateur de changer régulièrement son code à 4 chiffres.

    Pour approfondir les attentes du cahier des charges, nous avons également conçu une application Androïd pour faciliter l’utilisation de l’alarme. Notre système de surveillance est sous forme de boitier que l’on peut contrôler soit manuellement directement sur le support, soit grâce à son téléphone portable personnel.

    schémabloc

    Schéma simplifié des fonctionnalités de l’alarme sans la vérification et correction des codes entrés

    Ce tuto se décompose en 5 parties, que tu peux découvrir ci-dessous.

    1ère partie : Le matériel

    Pour commencer, il faut t’équiper. Et oui, un bon concepteur a toujours une bonne boîte à outils.

    Pour mener à bien ton projet d’alarme, il te faudra :

    • Une carte Arduino Mega avec le câble d’alimentation

    Carte Arduino Mega

    • Un écran LDC avec son potentiomètre
    • Un clavier matriciel

    Clavier matriciel

    • Un capteur Ultrasons HC-SR04
    • Un module Bluetooth (si tu veux contrôler le système avec ton téléphone)
    • Des fils et une plaquette
    • Un buzzer
    • Éventuellement plusieurs LEDs (couleurs différentes)

    Ça y est, tu as tout ce qu’il te faut ? Nous allons pouvoir attaquer la partie la plus intéressante, la programmation.

    2ème partie : La programmation sous Arduino

    Si tu veux d’abord t’entraîner avec tout ces nouveaux composants, il existe un logiciel en ligne Tinkercad qui permet de modéliser des circuits électriques comportant les différents éléments que nous allons utiliser ensuite.

    Pour commencer, télécharge et installe le logiciel Arduino. Nous allons t’expliquer certaines bases qui te serviront pour l’avenir.

    Fonctions et boucles

     →  1ère étape : void ActiverAlarme() 

    Nous allons commencer par écrire la fonction qui permet d’activer le système d’alarme : (clique sur la photo pour voir la vidéo)

    Cette fonction permet à l’utilisateur d’activer l’alarme en rentrant son code, dès lors qu’il appuie sur la touche A du menu. Celui-ci doit être le bon pour que le système s’active.

    Fonction Activation

    En traduction programmation, la chaîne de caractère que l’utilisateur va saisir sur le clavier matriciel doit être la même que celle prédéfinie pour le mot de passe. Nous devons donc, dans cette fonction, coder une vérification de la chaîne comportant le bon nombre de chiffre.

    Si le résultat de l’opération de vérification est correct, notre fonction va appeler une fonction d’activation void Activation() qui va lancer le compte à rebours et mettre en marche le détecteur Ultrasons.

    Lors de la saisie de son mot de passe, l’utilisateur est capable de se tromper. C’est pourquoi nous avons ajouté une fonction à la touche “C” qui permet d’effacer le début de la chaîne de caractères qu’il était en train de saisir. L’utilisateur peut aussi rentrer un code faux. Dans notre système de surveillance, nous avons décidé de laisser 3 chances à l’utilisateur pour réussir.

     →  2ème étape : void DesactiverAlarme() 

    Passons à la programmation de la fonction qui permet de désactiver l’alarme. L’appui sur la touche “A” du clavier lorsque le système d’alarme est activé doit permettre à l’utilisateur de désactiver son alarme. (Quand il rentre de son travail par exemple.)

    Cette fonction est de la même forme que void ActiverAlarme() sauf que lorsque le code est bon, le booléen (variable à deux états) alarmeActivee est mis à “false”, ce qui est utile pour les fonctions suivantes et pour le menu void Loop.

    →  3ème étape : void Activation()

    La fonction Activation lance un compte à rebours et active l’alarme dès lors que la fonction ActiverAlarme est vraie. Elle permet de mettre en marche les autres composants de notre système.

    void activation(){ // Fonction qui lance l'activation de l'alarme (lance le détecteur)
    
     lcd.clear();
     lcd.setCursor(1,0); // Place le curseur tout en haut à gauche de l'écran
     lcd.print("ALARME ACTIVEE");
     lcd.setCursor(1,1); // Place le cruseur sur la deuxième ligne de l'écan
     lcd.print("DANS ");
    
     int comptearebours = 9; // compte à rebours avant l'activation de l'alarme (10s)
     while (comptearebours != 0) {
      lcd.setCursor(10,1);
      lcd.print(comptearebours);
      comptearebours--;
      delay(1000); // toutes les secondes
     }
     lcd.clear(); // Efface l'écran
     lcd.setCursor(1,0);
     lcd.print("ALARME ACTIVEE");
     alarmeActivee = true;
     buzzer(); // Avertisseur sonore pour l'activation de l'alarme
     digitalWrite(ledverte, HIGH);
     delay (2000);
     digitalWrite(ledverte, LOW);
     lcd.clear();
     }

     →  4ème étape : void changerMotdepasse()

    L’appui sur la touche “B” de notre clavier matriciel permet à l’utilisateur de changer son mot de passe. Il doit dans un premier temps rentrer l’ancien code, ce qui lui permet d’accéder à cette fonctionnalité. Il en propose ensuite un nouveau qu’il doit confirmer.

     →  5ème étape : void intrus()

    La fonction la plus importante d’une alarme est sans aucun doute celle qui permet de détecter la présence malveillante d’un intrus. On utilise pour cela un capteur Ultrasons qui va mesurer une distance donnée à un intervalle précis. Le capteur envoie une impulsion qui va être reçue par une autre partie du capteur. Le temps que met l’ultrason à être envoyé puis reçu, va nous permettre de mesurer une distance. Si celle-ci est inférieure à la longueur définie au départ (espace autour du boitier dans la maison), alors cela veut dire qu’il y a la présence d’une personne non désirée.

    Cependant, le capteur est inactif dès lors que l’utilisateur appuie sur une touche de n’importe quel clavier connecté au système (soit le clavier matriciel, soit le clavier de l’application du téléphone).

    void intrus(){ // Fonction qui active l'alarme (bruit) en cas de présence suspecte
    
     tone(Piezo, 440);
     digitalWrite(ledrouge, HIGH);
     int c = 0;
     motdepassesaisi = "";
     lcd.clear();
     lcd.setCursor(2,0);
     lcd.print("SAISIR CODE");
    
     while(c < 4) {
      if (Serial.available() > 0){ // Connexion Bluetooth
       state = Serial.read();
       touche = state;
       Serial.flush();
      }
      else {
       touche = clavier.getKey();
      }
      if (touche){
       if (touche == '0' || touche == '1' || touche == '2' || touche == '3' ||
           touche == '4' || touche == '5' || touche == '6' || touche == '7' || 
           touche == '8' || touche == '9' ) {
            motdepassesaisi += touche;
            lcd.setCursor(c,1);
            lcd.print("*"); 
            delay(500);
            c++;
       }
      } 
     }
    
     if (motdepassesaisi == motdepasse) { // La sonnerie du buzzer est arrêtée si l'utilisateur a rentré le bon code
      distance = 5;
      digitalWrite(ledrouge, LOW);
      noTone(Piezo);
      lcd.clear();
      lcd.setCursor(4,0);
      lcd.print("OK CHEF"); 
      delay(1000);
      lcd.clear();
     }
    }

    À partir de là, il ne te reste plus qu’à mettre en forme le programme avec les fonctions void setup() et void Loop() qui sont la base du code Arduino. Il faut que tu définisses l’ordre des fonctions que tu appelles dans la boucle, et il faut incrémenter et initialiser les variables dont tu as besoin pour le programme.

    void setup() {
    
     lcd.begin(16,2); // écran LCD à 16 colonnes det 2 lignes
     pinMode(Piezo, OUTPUT); // Buzzer en SORTIE
     pinMode(trigPin, OUTPUT); // Capteur Ultrasons
     digitalWrite(trigPin, LOW);
     pinMode(echoPin, INPUT); // Capteur Ultrasons
     pinMode(ledverte, OUTPUT);
     Serial.begin (9600);
    }

    FONCTIONS Auxiliaires et supplémentaires

    Lors de nos phases de tests, nous avons choisis d’améliorer le programme de base avec différentes nouvelles fonctions, telles que : une fonction de correction, la possibilité de modifier sa saisie au clavier, et une fonction pour le son du buzzer…  Elles permettent de rendre l’utilisation de l’alarme plus facile. A toi de choisir si elles t’intéressent.

    3ème partie : montage et câblage

    Après finalisation du programme, il faut câbler et relier les composants entre eux. Grâce aux schémas fonctionnels disponibles sur le net, prend ton temps et réalise un beau montage en tenant compte des entrées Analogiques ou Digitales.

    Câblage écran LCD

    4éme partie : Conception Boitier

    Arrive le temps de mettre tout ton travail en boite ! Pour cela, plusieurs choix : soit tu fabriques un boitier en bois ou avec un matériau que tu affectionnes, soit avec une imprimante 3D sous SolidWorks ou tout autre logiciel de Conception Assistée par Ordinateur (CAO).

    Comme c’est ton alarme, choisi un design et des couleurs sympas qui te conviennent et qui s’associeraient facilement avec ton intérieur.

    Conception boitier    Boitiervert

    5ème partie : Amélioration pour l’utilisation

    Application sur Androïd

    Si tu veux pousser le projet plus loin, il est possible de créer d’autres interfaces entre le système et l’utilisateur. Par exemple, tu peux améliorer ton système d’alarme en créant une application utilisable sur ton smartphone. Nous avons choisis d’utiliser le logiciel en ligne MIT App Invetor qui permet de concevoir des applications utilisables sous Androïd.

    MIT App Inventor Interface MIT AppCodeBlocksMitAPP

    Utilisation TÉLÉCOMMANDE Infrarouge

    Nous avons aussi créé une fonction qui permet d’utiliser, et le clavier matriciel, et une télécommande InfraRouge, ce qui, comme l’application mobile, permet de contrôler le système de surveillance à distance.

    Télécommande IR

    Voilà ! C’est fini ! Tu as à présent une belle alarme que tu peux utiliser chez toi pour prévenir la présence d’un intrus chez toi. Bravo et merci d’avoir suivi ce petit Tuto !

    Coline & Léa – Peip2