IMA3/IMA4 2018/2020 P16 : Différence entre versions

De Wiki de Projets IMA
(→‎Semaine 19)
(→‎PCB)
 
(269 révisions intermédiaires par 5 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
 +
<include nopre noesc src="/home/pedago/pimasc/include/video-AntiHarcelementIMA32018-iframe.html" />
 
__TOC__
 
__TOC__
 
<br style="clear: both;"/>
 
<br style="clear: both;"/>
Ligne 361 : Ligne 362 :
  
  
−
[[Fichier:P16_video_popup.gif]|200px|center]
+
[[Fichier:P16_video_popup.gif|200px|center]]
  
  
Ligne 394 : Ligne 395 :
  
 
==Projet S7==
 
==Projet S7==
 +
 +
====Etat du projet en début du S7====
 +
 +
En ce début d'année, nous avons pour notre première séance du S7 fait un bilan sur l'état d'avancement de notre projet.
 +
Avec les différentes remarques que nous avons eu lors notre oral de présentation finale au S6 et lors de la petite entrevue avec nos enseignants encadrants pendant cette première séance, nous devons modifier et repenser certains points vitaux de ce projet.
 +
 +
 +
Ces remarques concernent principalement notre système de détection et la méthode employée pour traiter les données.
 +
 +
*La détection n'est pas parfaite. En effet, nous n'utilisons pas correctement nos capteurs de force car nous ne nous servons pas des données analogiques mais d'une information binaire afin de savoir si la personne est touchée. Or ces capteurs sont utilisés pour détecter une certaine pression et dans le cas d'une caresse (souvent le cas dans un harcèlement), nous sommes presque incapable de la détecter. Ce point critique est donc à revoir pour visualiser correctement une touche.
 +
 +
*Par rapport à notre méthode de traitement des données, nous devons clairement identifier un cadre d'utilisation pour valider ou non les différents cas de figure que nous avons pensé. Mais alors comment arriver à différencier une touche tout à fait banale ou amicale d'un harcèlement sachant que la force exercée est exactement la même. Monsieur Boé nous a parlé de mettre en place le DeepLearning. Nous allons donc étudier la question.
 +
 +
 +
Pour ce semestre, nous allons donc repenser notre prototype afin de proposer un véritable dispositif de détection. Dans un même temps, une équipe se concentrera à réalisation d'une nouvelle application. Et pour finir, nous proposerons une liste de matériel répondant au mieux à notre cahier des charges pour la réalisation finale de notre prototype au S8.
 +
 +
====Amélioration du prototype====
 +
 +
=====Etat de l'art=====
 +
 +
=====FabricKeyboard du MIT=====
 +
 +
Le FabricKeyboard du MIT est un tissu doté de différents capteurs. Il dispose de capteurs pour détecter le toucher, la proximité, les champs électriques, ainsi que les déformations telles que l’étirement.
 +
 +
Cette invention est intéressante, cependant son fonctionnement est assez complexe, et pour notre projet nous n'avons besoin que de détecter un toucher. C'est pour cela que nous n'avons pas retenu le FabricKeyboard, et avons fait d'autres recherches.
 +
 +
 +
 +
[[Fichier:FabricKeyboard.jpg|500px|center]]
 +
 +
 +
 +
 +
En continuant nos recherches, nous avons trouvés un moyen de faire un capteur de touche avec de simples résistances et une carte Arduino.
 +
 +
=====Conception de capteur dit tactile=====
 +
 +
Afin de détecter plus précisément et efficacement les touches sur une personne, nous avons décidé de changer nos détecteurs de force avec d'autres capteurs basés sur le principe d'un écran tactile. Nous avons commencé par effectuer des recherches pour comprendre plus en détail le fonctionnement d'un tel écran. Nous avons pu voir qu'il s'agit d'une technologie capacitive fonctionnant sur la décharge du corps humain en travers une résistance symbolisée par l'écran.
 +
 +
Après ces recherches, nous nous sommes demandé comment mettre en place un tel système. Pour simuler ces capteurs "tactiles", nous avons découpé des bandes d'aluminium pour les fixer sur un support. Chaque bande d'aluminium est connecté à une pin d'entrée/sortie de notre arduino avec une résistance de type pull-up.
 +
 +
 +
[[Fichier:P16_montage_v1.PNG|500px|center]]
 +
 +
[[Fichier:P16_schema_v1.PNG|500px|center]]
 +
 +
 +
La résistance est une résistance de pull-up et la capacité correspond au capteur tactile qui est une bande d'aluminium. Un courant vient charger la résistance de pull-up. Lorsqu'on vient toucher la bande d'aluminium, le corps humain vient se décharger au travers de la résistance et ainsi peut voir que le capteur est actif.
 +
 +
Les premières tests étaient concluant mais nous avons pu observer que des latences survenaient lorsque deux capteurs étaient touchés en même temps et aussi lorsqu'ils s'étaient en contact.
 +
 +
 +
Pour palier à ce problème, nous avons vu que nous pouvions mettre une pin commune avec nos capteurs. On utilise une pin d'envoie et une autre de réception. Le schéma de réalisation change légèrement et donne ceci.
 +
 +
 +
[[Fichier:P16_schema_v2.PNG|500px|center]]
 +
 +
[[Fichier:P16_moniteur_serie.PNG|center]]
 +
 +
 +
On peut voir sur le moniteur série d'Arduino différentes valeurs. Pour obtenir ces valeurs, nous avons utilisé la bibliothèque CapacitiveSensor qui permet de détecter la capacité du corps humain. On a implémenté la méthode suivante pour utiliser cette bibliothèque. On fait basculer la pin d'envoi vers un nouvel état et on attend que la pin de réception change aussi d'état. Une variable est incrémentée pour calculer le temps de changement d'état. Lorsque l'on touche notre capteur, on obtient par conversion la valeur de notre capacité.
 +
 +
On peut voir que cette valeur est importante quand on ne touche qu'un capteur et diminue quand plusieurs capteurs sont touchés en même temps par quelqu'un. Dans le cas de figure où les capteurs sont en contact, la valeur ne dépassent pas les 1000. Ce point nous permet donc isolé ces valeurs et de donc de savoir comment gérer l'un des problème que nous avons pu évoquer lors de notre soutenance.
 +
 +
 +
Cette méthode est concluante car on peut bien visualiser la touche sur un des capteurs. Pour chaque capteur, nous avons donc besoin d'une pin commune et de n pins (n est le nombre de capteurs). On peut envisager de mettre en place cette méthode. Par contre, la lenteur de l'arduino peut nous poser problème. On peut donc mettre en pratique nos cours de microprocesseur et de système pour optimiser les cycles du CPU et ainsi être plus rapide.
 +
 +
=====Intégration au prototype=====
 +
 +
Maintenant que nous avons trouvé la méthode idéale pour la détection de touche sur une personne, nous devons penser à la manière d'intégrer ce système au mieux tout en respectant les contraintes techniques de notre cahier des charges à savoir le point sur la discrétion du système.
 +
 +
 +
La mise en place de bande de papier aluminium dans un vêtement n'est pas vraiment idéale et discrète. Nous allons donc réfléchi à une solution permettant d'intégrer au mieux notre nouveau système de détection.
 +
<center>
 +
<gallery perrow="2" mode="nolines">
 +
Fichier:P16_cuivre.PNG|Bobine de cuivre
 +
Fichier:P16_fil.PNG|Bobine de fil conducteur
 +
</gallery>
 +
</center>
 +
 +
 +
 +
*La première idée consistait à utiliser des bandes autocollante cuivre provenant d'une bobine. Mais les soucis de cette idée sont d'une part esthétique (on peut voir ces bandes sous le vêtement, et d'autre part technique, à la long les bandes peuvent se décoller voir se déchirer.
 +
*La second idée nous est venu avec nos recherche sur les tissus tactiles. En effet, l'équipe ATAP de Google a réalisé le projet Jacquart qui consiste à intégrer de la technologie dans les vêtements afin de pouvoir avec des gestes répondre à un appel, écouter de la musique, lire un SMS et bien d'autres fonctions. Pour cela, ils utilisent un fil conducteur intégré au tissus. Nous allons donc nous baser sur cette solution avec des zones délimitées sur le vêtement. Chaque zone pourra donc vérifier une partie du corps avec un seul capteur tactile sur la zone en question. Bien évidement, le vêtement sera doubler pour éviter de prendre en compte la propre impédance de son corps.
 +
 +
 +
 +
<center>
 +
<gallery perrow="2" mode="nolines">
 +
Fichier:P16_zone_corps_av.PNG | Vue avant du corps
 +
Fichier:P16_zone_corps_ar.png | Vue arrière du corps
 +
</gallery>
 +
 +
</center>
 +
 +
 +
Pour compléter notre dispositif, nous avons décidé de conserver nos ancien capteur de force. En effet, avec les valeurs qu'ils peuvent envoyer, nous pouvons affiner l'analyse de la touche. Pour de grosses valeurs, on peut par exemple savoir qu'un ami nous fait une accolade ou quand on s'assoit. Dans le cas d'un harcèlement, on se base sur le fait que cela soit de la discrétion avec donc de petites touches faibles en intensité. On pourra donc être capable de différencier les différents cas de figure qui se présentent à nous.
 +
 +
 +
Pour intégrer tout notre système dans un vêtement, nous avons vu qu'il existait des modules conçus pour une utilisation sur vêtement. Il s'agit des modules Lilypad. Le module principal est composé d'un atmega328, de 14 entrées/sorties et de 6 entrées analogiques. La carte vient s'enrichir d'autres modules comme des boutons, des Leds, un vibreur, un support de pile. Ces modules se présentent sous la forme suivante. L'avantage de ces modules est qu'ils sont très simples à intégrer et les options que nous voulons rajouter correspondent à des modules existants.
 +
 +
<center>
 +
<gallery perrow="4" mode="nolines">
 +
Fichier:P16_lilypad.PNG | Module Lilypad
 +
Fichier:P16_bouton.PNG | Module bouton
 +
Fichier:P16_vibreur.PNG | Module vibrant
 +
Fichier:P16_support_pile.PNG | Module support de pile
 +
</gallery>
 +
</center>
 +
 +
====Nouvelle application====
 +
 +
 +
Nous avons commencé à développer notre application après les différents tests des capteurs tactiles. Pour cette nouvelle application, nous avons arrêté d'utiliser MIT App Inventor au profit du logiciel AndroidStudio. Il s'agit d'un IDE de développement basé sur Intellij. Pour commencer à utiliser ce nouvel environnement, nous avons suivi un cours provenant d'un master informatique du campus.
 +
 +
 +
Le principe de l'application est le suivant :
 +
 +
Tout d'abord nous avons un programme arduino qui détecte lorsqu'une zone du vêtement est touchée. Par exemple, si la zone numéro '1' est touchée, le bit numéro '1' de la trame de donnée bluetooth prend la valeur 1 (1 = touche / 0 = pas de touche). Ensuite, on envoie la trame complète au téléphone par liaison bluetooth, et sur l'application Android on traite les données. On regarde quels bits sont à '1', et on affiche les zones correspondantes sur l'interface graphique.
 +
En parallèle avec l'affichage graphique, on lance un Timer pour chaque capteurs afin d'afficher le temps de touche par zone, ainsi que le temps total de touche toutes zones confondues. Ces différents Timers permettent ensuite d'avoir un aperçu des zones qui sont le plus souvent touchées.
 +
 +
D'autres fonctionnalités sont aussi présentes : l'une d'entres-elles est l'envoi d'un SMS ou l'appel d'une personne. L'utilisateur peut choisir d'activer l'envoi de SMS, ou l'appel, à un numéro préalablement enregistré dans une page de configuration. Cette fonctionnalité s'effectue alors si la personne se sent en danger.
 +
 +
 +
[[Fichier:SchemaFoncAppli.png|750px|center]]
 +
 +
 +
=====Connexion au Bluetooth=====
 +
 +
 +
Pour commencer, nous avons établit la liaison Bluetooth entre l'arduino et la nouvelle application. On a tout d'abord déclarer deux permissions, une pour effectuer la communication et se connecter et l'autre pour récupérer des informations de l'utilisation telles que la localisation.
 +
 +
<uses-permission android:name="android.permission.BLUETOOTH"/>
 +
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
 +
 +
Après avoir initialisé l'application, la fonction initiaBluetoothProcess() vient établir la liaison avec le module Bluetooth. Les informations envoyées et reçues sont stockées à partir de la fonction ConnectedThread().
 +
 +
[[Fichier:P16_bluetooth_connexion.PNG|750px|center]]
 +
 +
 +
Nous avons aussi pris le temps de développer une fonction permettant d'annuler la connexion Bluetooth.
 +
 +
=====Appel et SMS=====
 +
 +
 +
 +
Nous avons ajouté comme fonctionnalité le paramétrage pour prévenir ou demander de l'aide. On peut choisir entre émettre un appel et envoyer un SMS avec le numéro de notre choix. Nous avons pensé à sauvegarder le choix car nous avons vu que lorsque l'on quittait l'application, le numéro de téléphone n'est pas enregistré. Il fallait donc le noter à chaque utilisation ce qui n'est pas vraiment pratique.
 +
 +
 +
[[Fichier:P16_appel_sms.PNG|750px|center]]
 +
 +
 +
 +
[[Fichier:P16_sauvegarde_donnees.PNG|750px|center]]
 +
 +
 +
Aussi nous avons mis en place un moyen de prévenir quelqu'un lorsque l'on se sent en insécurité. Pour prévenir une personne suivant le choix fait dans les paramétrages de l'application, lorsque l'on appuie cinq fois sur un intervalle de temps de 0,5 secondes l'appel ou le sms est automatiquement envoyé.
 +
On peut alors penser envoyer seulement un sms avec les informations de localisation pour recevoir de l'aide.
 +
 +
=====Partie Graphique=====
 +
 +
Avec AndroidStudio, on pouvait à l'aide d'un simulateur voir en direct les modifications que l'on effectuait ce qui nous a été très pratique pour la conception graphique de cette dernière.
 +
 +
[[Fichier:P16_graphique.PNG | 750px | center]]
 +
 +
 +
On a donc créé plusieurs pages pour pouvoir :
 +
*Se connecter au Bluetooth.
 +
*Visualiser son corps et les touches
 +
*Paramétrer le numéro de téléphone et choisir entre SMS et Appel
 +
*Voir les détails des touches en temps ou en pourcentage.
 +
 +
Une fois que nous avons compris la méthode de conception, il nous était simple de la dupliquer pour en faire d'autres.
 +
 +
 +
Les fonctions de bases ont été codé avec succès. Il ne nous reste plus grand chose à faire du côté de l'application. On peut ajouter une page de connexion avec un login et un mot de passe, choisir les informations à envoyer par SMS, un mode silencieux pour désactiver pendant une durée définie ou indéterminée. On prévoira aussi une nouvelle phase de design pour rendre l'application plus attractive et simple d'utilisation.
 +
 +
====Nouvelle liste de matériel et explication de nos choix====
 +
 +
A la suite de nos tests, nous pouvons donc concevoir une nouvelle liste de matériel nécessaire pour la réalisation de notre prototype final au S8 sachant que nous devons réaliser :
 +
*Un PCB avec arduino, composants passifs (résistance, condensateur, ...), borniers, et module vibrant
 +
*Notre prototype avec capteurs de force et zone avec fil conducteur
 +
 +
Concernant l'arduino, nous avons besoin de :
 +
*6 pins analogiques pour les capteurs de force.
 +
*2 pins digitales pour la liaison Bluetooth.
 +
*14 pins digitales + 2 pins communes pour les zones tactiles.
 +
*1 pin digitale pour un module vibrant.
 +
*1 pin digitale pour un bouton.
 +
 +
Soit au total 6 pins analogiques et 20 pins digitales.
 +
Nous ne retenons pas la solution des modules Lilypad car le nombre d'entrées digitales est trop juste. De plus, la solution d'un PCB va nous permettre d'avoir une carte encore plus fonctionnelle et répondant parfaitement à nos besoins.
 +
 +
 +
Pour le PCB :
 +
*Un arduino micro
 +
*Résistances CMS de 10MΩ | 0603
 +
*Capacités CMS de 0.33µF | 1206
 +
*Capacités CMS de 0.1µF | 1206
 +
*Un régulateur de tension CMS LM7805MPX si on intègre directement un microcontrôleur sur le PCB
 +
*Borniers
 +
 +
 +
Pour le prototype :
 +
*Bobines de fils conducteur.
 +
*2 capteurs de force FSR02CE.
 +
*10 capteurs de force FSR402S.
 +
*Module Vibrant.
 +
*Bouton discret.
 +
 +
===Objectif au S8===
 +
 +
Maintenant que nous savons comment réaliser notre système, il ne nous reste plus qu'à le mettre en place et de trouver la bonne méthode d'exploitation des données. Nous n'arrivons pas bien à voir comment développer le DeepLearning avec notre projet mais avec les différents capteurs et les scénarios, nous pensions avoir trouvé un début de solution.
 +
 +
 +
 +
Pour le S8, nous allons donc :
 +
 +
*Concevoir un PCB | 1 personne | 2-3 séances
 +
*Souder les composants à notre PCB | 1 personne | 1 séance
 +
 +
*Définir et mettre en place les capteurs | Le groupe pour bien les définir et 1 personne pour la mise en place | 1 séance
 +
 +
*Ajouter le reste des fonctionnalités sur l'application | 2 personnes | 2 séances
 +
*Terminer la partie graphique de l'application | 1 personne | A la fin
 +
 +
*Ajouter la méthode de traitement des données | 1-2 personnes | Toutes les séances
 +
*Tester le prototype final avec tous les éléments ou partiellement | Le groupe après chaque modification | Toutes les séances
 +
 +
===REF===
 +
 +
https://dam-prod.media.mit.edu/x/2017/06/15/paper0066.pdf
 +
 +
https://www.media.mit.edu/projects/sensorknits/overview/
 +
 +
https://www.media.mit.edu/research/?filter=everything&tag=wearable-computing
  
 
===Documents Rendus===
 
===Documents Rendus===
  
 
==Projet S8==
 
==Projet S8==
 +
 +
Pour continuer notre projet au S8, nous avons trois objectifs.
 +
* Concevoir et réaliser un PCB.
 +
* Programmer notre système de detection.
 +
* Finaliser l'application.
 +
 +
=== Modification du système ===
 +
 +
En ce début de semestre, nous avons pris une décision qui va modifier notre dispositif.
 +
Avec de grandes zones à couvrir sur le corps, nous avons besoin d'un grand nombre d'entrées digitales et analogiques. Nous pensons créer un PC à partir d'un atmega 2560. En effet, ce microcontrôleur dispose de 54 pins digitales et de 16 pins analogiques.
 +
 +
Mais ce dispositif a de nombreux inconvénients :
 +
* Le système est central et la longueur des différents câbles va apporter des perturbations dues aux impédances.
 +
* Le grand nombre d'entrées va ralentir le dispositif.
 +
 +
 +
Pour palier à ce problème, nous avons repenser notre système.
 +
Nous avons eu comme idée d'implanter un système maître - esclave avec une liaison I2C.
 +
 +
Le maître aura un rôle de récepteur et les esclaves seront les transmetteurs.
 +
A chaque instant, les esclaves enverront les informations des capteurs via une trame au maître qui analysera ces données. Si la situation est dangereuse, il demandera à un esclave d'actionner un moteur vibrant et dans le temps, il enverra un SMS ou un appel pour prévenir quelqu'un du danger.
 +
 +
[[Fichier:P16_systeme_synoptique.PNG|500px|center]]
 +
 +
Nous avons donc décidé d'assigner une zone du corps à un seul esclave, cela permettra de pouvoir couvrir une plus large zone qu'avec notre idée initiale. Aussi, grâce à ce nouveau système, il devient plus modulable. La carte des esclaves sera généralisée pour pouvoir être disposé à n'importe quel endroit. On peut ajouter ou supprimer des capteurs plus facilement selon la personne. Par contre, les différents changements devront être pris en compte sur l'application.
 +
 +
=== PCB ===
 +
 +
 +
Après avoir modifié notre système, on va pouvoir réaliser notre PCB avec ALTIUM DESIGNER.
 +
 +
Au début, nous pensions utiliser une atmega 2560 mais après réflexion et découverte d'une méthode maître - esclave, nous avons choisi de partir sur un Atmega 328p.
 +
 +
On aura deux PCB différents : un pour le maître et un autre pour les esclaves.
 +
Dans la conception du PCB esclave, nous avons décidé qu'ils seront tous identiques. En effet, dans le cas où l'on souhaite ajouter des capteurs sur un module pas assez précis, on va penser à prévoir la place et le matériel nécessaire pour les accueillir. Cela nous permet aussi de standardiser notre système.
 +
 +
 +
Le maître sera composé de :
 +
* Un Atmega 328p.
 +
* Un régulateur de tension.
 +
* Un module Bluetooth.
 +
* Des pins pour le téléversement.
 +
 +
 +
Et les esclaves seront composés de :
 +
* Un Atmega 328p.
 +
* Capteurs capacitifs.
 +
* Capteurs de forces.
 +
* Un module vibrant (Seulement pour un seul).
 +
* Des pins pour le téléversement.
 +
 +
 +
Au départ nous avons choisi d'intégrer un bouton pour que l'utilisateur puisse valider des demandes ou signaler un problème. Mais pour des soucis d'encombrement mais aussi d'efficacité, on a choisi de le remplacer par une séquence de détection sur les capteurs de touche. En effet, dans le feu de l'action, la personne n'arrivera pas forcément à trouver le petit bouton pour demander de l'aide. Il sera donc plus facile de demander de l'aide.
 +
 +
Les esclaves seront donc déportés du maître et proches de leur zone afin d'éviter les impédances et les erreurs de détection.
 +
On réalise les PCB suivant les différents câblages que nous avons effectués sur notre breadboard. Pour se donner une idée sur le positionnement des composants, on suit d'abord les règles de base (condensateur au plus près, taille des pistes et espacement entre piste et composant). Pour finir, on vient ajouter un plan de masse.
 +
 +
Grâce aux dernières remarques de Monsieur Boé, nous avons ajouté les résistances de pull up sur le bus I2C et aussi une autre résistance sur la pin Reset et entre le quartz.
 +
 +
 +
==== Gestion des empreintes ====
 +
 +
 +
Après la conception des schémas électriques, nous avons pu voir que certaines empreintes n'étaient pas disponibles. Il a donc fallu recréer ces différentes empreintes (Quartz | Régulateur de tension | Connecteurs d'entrées/sorties). Grâce aux datasheets, on va pouvoir réaliser nous-mêmes les empreintes que ce soit pour le schéma ou pour le PCB.
 +
 +
Grâce à de nombreux tutoriels et aux documents de l'école, on vient suivre la procédure pour créer un composant dans Altium.
 +
 +
* Dans le cas d'un composant sans empreinte, on vient ajouter au projet une librairie PCB. Ensuite, on dessine son empreinte. On commence par ajouter une pastille, on adapte sa taille aux dimensions voulues puis on la duplique en fonction du nombre de pattes sur le composant. Pour placer nos pastilles, on va travailler par symétrie. On se base comme si le composant était centré sur (0,0) et on vient disposer la pastille à sa position avec les données de la datasheet. On doit aussi ajouter l'encombrement du composant. Il ne nous reste plus qu'à assimiler cette empreinte au bon composant. Dans les propriétés du composant, on vient ajouter la librairie avec notre empreinte dans la partie [] en cliquant sur add.
 +
 +
* Si nous n'avons pas le composant dans une bibliothèque, il faut ajouter une librairie schématique, puis dessiner le composant symboliquement et enfin créer l'empreinte en suivant la même méthode décrite précédemment.
 +
 +
Il est important aussi de faire correspondre les différents chaque pin à sa pastille correspondante. Lorsque les modifications sont fini, il ne faut pas oublier de réactualiser le PCB. Il ne reste plus qu'à relier le composant au reste du PCB.
 +
 +
{| class="wikitable center" style="margin: auto;"
 +
|[[Fichier:P16_composant_perso_schematic.png|500px|center]]
 +
Vue schématique des composants créés
 +
 +
|[[Fichier:P16_composant_perso_pcb.png|500px|center]]
 +
Vue PCB des composants créés
 +
|}
 +
 +
===== Quartz =====
 +
 +
Le quartz est un composant simple à réaliser. Dans la datasheet, on retrouve les informations sur la taille du composant. Il nous est donc facile de recréer son empreinte. Celle-ci ne comprend que deux pastilles de même taille et opposées par simple symétrie. Lorsque l'on a fini de générer son empreinte, on obtient ces vues que l'on peut directement intégrer dans notre schéma.
 +
 +
 +
{| class="wikitable center" style="margin: auto;"
 +
|[[Fichier:P16_dimension_quartz.PNG|300px|center]]
 +
Vue dimension de la datasheet
 +
 +
|[[Fichier:P16_quartz_schematic.png|200px|center]]
 +
Schéma électrique du quartz
 +
 +
|[[Fichier:P16_quartz_pcb.png|300px|center]]
 +
Empreinte du quartz
 +
|}
 +
 +
===== Régulateur de tension =====
 +
 +
Tout comme le quartz, on suit la même procédure. On a dû par contre faire aussi bien la partie schématique que la partie PCB car nous n'avons pas trouvé de librairie avec ce composant. On n'oublie pas d'ajouter la masse commune du composant. La partie la plus longue était de comprendre les dimensions pour placer correctement les pastilles de dimensions différentes cette fois.
 +
 +
{| class="wikitable center" style="margin: auto;"
 +
|
 +
[[Fichier:P16_regulateur_datasheet.png|300px|center]]
 +
Vue dimension de la datasheet
 +
 +
|[[Fichier:P16_regulateur_schematic.png|200px|center]]
 +
Schéma électrique du régulateur
 +
 +
|[[Fichier:P16_regulateur_pcb.png|300px|center]]
 +
Empreinte du régulateur
 +
|}
 +
 +
===== Connecteurs des capteurs =====
 +
 +
Au début nous pensons utiliser de simples trous et venir souder nos fils à la carte. Mais les remarques de M.Boé nous ont permis de changer d'avis et d'utiliser plutôt des pastilles rectangulaires. Avec cela, nous sommes sûrs d'avoir une bonne connexion avec nos pistes et aussi éviter les faux contacts.
 +
 +
On vient créer tous les connecteurs dont nous avons besoin en fonction du nombre de pins sur chaque. Nous avons pris une pastille de 3*6 mm et l'espace entre chaque pin est adapté en fonction du besoin. Pour le capteur de force, il nous faut laisser un peu plus d'espace pour ne pas gêner la piste de +5V.
 +
 +
Pour les connecteurs des capteurs, nous nous sommes arrangés pour laisser une place afin de pouvoir positionner les résistances au plus près, pour gagner en place et simplifier le routage.
 +
 +
 +
Aussi après avoir fini nos cartes, nous avons avons modifié la prise du module bluetooth. En effet, à l'origine, nous avons juste mis les 4 pins nécessaires mais nous avons vu que lorsque l'on viendrait souder le module sur la carte, les 2 pins extérieures seraient en contact avec le plan de masse. Nous avons donc rajouté ces deux pins à notre composant pour éviter ce problème.
 +
 +
 +
{| class="wikitable center" style="margin: auto;"
 +
|[[Fichier:P16_connecteur_schematic.png|400px|center]]
 +
Vue schématique des connecteurs
 +
 +
|[[Fichier:P16_connecteur_pcb.png|400px|center]]
 +
Vue PCB des connecteurs
 +
|}
 +
 +
==== Carte maître ====
 +
 +
 +
Nous avons commencé par réaliser la carte maître. On commence par positionner notre atmega 328-p en prenant soin de bien choisir la version CMS.
 +
 +
Ensuite, on ajoute les capacités de découpage et la partie alimentation. On peut remarquer qu'il y a deux connecteurs alimentation sur notre schéma. Le premier correspond à l'entrée de la tension de la batterie externe et le second à la sortie du régulateur de tension. On ne voulait pas s'encombrer de plusieurs câbles à l'entrée de la batterie et d'un côté pratique et économique, on ne veut pas ajouter un régulateur de tension sur chaque carte.
 +
 +
Il nous reste à gérer la partie Bluetooth, ISP2 et I2C. On place nos connecteurs et ensuite on relie aux pins de l'atmega.
 +
 +
 +
[[Fichier:P16_maitre_schematic_V2.PNG|400px|center]]
 +
 +
On peut passer à la partie routage en suivant les règles que nous avons pu voir en cours et avec les documents disponibles sur le wiki. On commence tout d'abord par bien définir nos règles pour ne pas avoir de soucis à la fin de du routage. Une fois fini, on obtient la carte suivante. On a choisi de concevoir sur deux couches. Une fois tout le routage terminé, on n'oublie pas d'ajouter un plan de masse et de faire correspondre ce plan avec le nom du net (GND).
 +
 +
{| class="wikitable center" style="margin: auto;"
 +
|
 +
[[Fichier:P16_maitre_pcb_V2.PNG|400px|center]]
 +
Vue PCB de la carte maître
 +
 +
|
 +
[[Fichier:P16_maitre_pcb_masse_V2.PNG|400px|center]]
 +
Vue PCB avec le plan de masse
 +
|}
 +
 +
==== Carte esclave ====
 +
 +
Le développement de la seconde carte ne s'est pas avéré si différent que celui de la première. On travaille exactement de la même manière que pour la carte maître. Une fois que toutes les fonctions identiques ont été positionnées, on peut commencer à intégrer les besoins propres à cette carte.
 +
 +
On commence par mettre en place nos capteurs tactiles en suivant le schéma montré au S7. Sachant que nous avons choisi de positionner 6 capteurs sur chaque carte esclave, on les ajoute et on les relie à notre microcontrôleur. Ensuite on fait la même chose avec nos quatre capteurs de force.
 +
 +
 +
[[Fichier:P16_esclave_schematic_V2.PNG|400px|center]]
 +
 +
Pour le route de la carte esclave, on procède de la même manière que celui de la carte maître.
 +
 +
{| class="wikitable center" style="margin: auto;"
 +
|
 +
[[Fichier:P16_esclave_pcb_V2.PNG|400px|center]]
 +
Vue PCB de la carte esclave
 +
 +
|
 +
[[Fichier:P16_esclave_pcb_masse_V2.PNG|400px|center]]
 +
Vue PCB avec le plan de masse
 +
|}
 +
 +
==== Réalisation des PCB ====
 +
 +
En attente de savoir si on peut les faire.
 +
 +
=== Programmation ===
 +
 +
 +
 +
Globalement, notre programme de détection reste le même par rapport au S7. Nous avons par contre adapté ce dernier pour la communication maître - esclave.
 +
 +
 +
{| class="wikitable center" style="margin: auto;"
 +
|
 +
|[[Fichier:P16_Code_esclave.PNG|400px|center]]
 +
Code des cartes "esclaves"
 +
|
 +
|[[Fichier:P16_Code_maitre.PNG|500px|center]]
 +
Code de la carte "maître"
 +
|}
 +
 +
 +
 +
Pour les cartes 'esclaves', on effectue 2 boucles ''for'', une pour chaque type de capteur (tactile et force). On stocke la valeur de chacun des capteurs dans une variable, puis on envoie cette valeur via la liaison I2C. Pour les capteurs de force, on transforme la valeur du capteur qui varie entre 0 et 1024 en une valeur qui varie entre 0 et 15. Ceci nous permet d'enregistrer la valeur de 2 capteurs de force dans un seul octet (un capteur sur les 4 bits de poids faible, et l'autre sur les bits de poids fort).
 +
 +
 +
Pour la carte 'maître', on récupère les valeurs de chacun des capteurs sur chacune des cartes esclaves. Ensuite, on concatène les valeurs des capteurs de force dans une première variable et les valeurs des capteurs tactiles dans une autre variable. Pour finir, nous envoyons la trame de données par la liaison bluetooth directement sur le téléphone.
 +
 +
 +
==== Protocole de communication Maître - Esclave ====
 +
 +
 +
On connecte la carte maître et les cartes esclaves par la liaison I2C disponible sur les Atmega 328p. Le bus I2C permet de faire communiquer entre eux des composants électroniques très divers grâce à seulement trois fils : Un signal de données : SDA, un signal d’horloge : SCL et un signal de référence électrique : la masse. Le nombre maximal d’équipements est limité par le nombre d’adresses disponibles, 7 bits d’adressage et un bit R/W ce qui donne un total de 127 esclaves possibles. C'est largement suffisant pour notre dispositif.
 +
 +
 +
Pour mettre en place ce bus, on utilise la bibliothèque Wire.
 +
On commence par initialiser la liaison avec la commande Wire.begin() dans le code du maître. Idem pour l'esclave en ajoutant son adresse en paramètre.
 +
Ensuite, la fonction Wire.requestFrom() permet au maître de demander aux esclaves les données. On se sert de Wire.read() pour récupérer cet octet.
 +
Côté esclave, on utilise Wire.onRequest() pour faire appel à notre fonction requestEvents() quand le maître demande l'état des capteurs.
 +
 +
 +
 +
Chaque carte esclave dispose de 1 à 6 capteurs tactiles ainsi que de 0 à 2 capteurs de force.
 +
 +
Le maître envoie une requête à chacun des esclaves pour obtenir l'état des capteurs et il envoie ensuite les données via une liaison bluetooth vers le téléphone qui dispose de l'application.
 +
 +
Les différents états des capteurs de chaque atmega328p esclave sont envoyés sous forme de trame d'octets de la forme suivante :
 +
 +
[[Fichier:Slave1_capt_force_touch.JPG|500px|center]]
 +
 +
Chaque esclave envoie une trame de 2 octets l’un après l’autre. L’octet de poids faible correspond  la valeur des capteurs tactiles tout ou rien et l’octet de poids fort correspond aux valeurs analogiques des 2 capteurs de force allant de 0 à 15. Ensuite, le maître récupère les trames une par une et concatène les valeurs des capteurs tactiles entre-elles et fait de même pour les capteurs de forces.
 +
 +
Voici un exemple pour illustrer cette trame de données.
 +
 +
[[Fichier:P16_exemple_trame.png|500px|center]]
 +
 +
On voit sur la gauche les états des capteurs de touche (ici 2 capteurs) qui peuvent prendre deux valeurs : 0 si le capteur n'est pas touché et 1 si quelqu'un touche le capteur. Sur la droite on a la valeur des capteurs de force (sur 4 bits).
 +
 +
Ensuite l'atmega328p maître réceptionne toutes les informations provenant de ses atmega328p esclaves et les envoie par bluetooth au téléphone :
 +
 +
[[Fichier:Master_capt_force_touch.JPG|500px|center]]
 +
 +
 +
On voit sur la gauche l'état de tous les capteurs confondus, sous forme décimale, puis nous avons la trame de données qui va être envoyée au téléphone par bluetooth. Cette trame se décompose en deux parties, tout d'abord on aperçoit le caractère 'f' qui est utilisé comme caractère de début de trame, ce caractère est suivi de l'état des capteurs de touche. Ensuite, on a une deuxième partie commençant par le caractère 'd' est qui est suivi des valeurs des capteurs de force (sur 4 bits : l'intensité de la force est mesurée sur une échelle de 0 à 15).
 +
 +
==== Téléversement sur les PCB ====
 +
 +
Etant donné que nous avons pris le choix de réaliser nos propres circuits imprimés, nous avons dû trouver une solution sur la façon d'implanter nos programmes dans nos microcontrôleurs. Pour la discrétion que doit avoir notre dispositif, nous avons choisi de ne pas mettre de prise USB. Cela nous permet de gagner de la place.
 +
 +
On pouvait prévoir les sorties Rx et Tx et utiliser un module annexe pour le téléversement.
 +
 +
Finalement, notre choix s'est porté sur une méthode qui consiste à utiliser une carte arduino comme programmateur. Il s'agit du protocole ISP.
 +
Nous avons besoin de 6 pins dont VCC et GND. Les trois autres pins sont :
 +
*MISO
 +
*MOSI
 +
*SCK
 +
 +
Le schéma suivant présente la méthode de fonctionnement de ce protocole.
 +
[[Fichier:P16_arduinoISP.jpg|300px|center]]
 +
 +
 +
Avec ce protocole, il nous est toujours possible d'utiliser l'IDE Arduino. La seule chose à changer est le type de programmeur. Dans [Outils] puis [Programmateur], il faut sélectionner "Arduino as ISP".
 +
[[Fichier:P16_arduino_as_ISP.png|500px|center]]
 +
 +
 +
Par contre, nous avons vu qu'il était nécessaire de laisser les pins Rx et Tx vide lors de cette manipulation. Pour les cartes esclaves, cela ne pose pas de soucis mais nous utilisons Rx et Tx pour le Bluetooth sur la carte maître. Pour palier à ce problème, nous avons ajouté un commutateur sur la carte. Quand on voudra téléverser notre programme, il suffira de changer la position ON sur OFF pour 'déconnecter' les pins au Bluetooth.
 +
 +
[[Fichier:P16_ajout_commutateur.png|500px|center]]
 +
 +
=== Application smartphone ===
 +
 +
Sur l'application, nous visualisons toujours les différentes zones touchées sur le vêtement, et nous avons ajouté des capteurs de force pour visualiser l'intensité du touché.
 +
 +
Comme expliqué précédemment, la carte avec l'atmega328p maître envoie sous trame constituée de 2 messages, un message contenant les informations des capteurs de touche, et une seconde contenant les informations des capteurs de force.
 +
 +
Nous découpons ces 2 trames et stockons les informations dans des variables (côté application Android) et nous faisons un lien entre les capteurs de touche et les capteurs de force en fonction des zones.
 +
 +
Les capteurs de force ont une valeur entre 0 et 15, plus cette valeur est élevée, plus la pression captée par le capteur de force est intense. Le tableau ci-dessous montre les différentes valeurs que la carte esclave envoie à la carte maître en fonction du type de touche capté par le capteur de force :
 +
 +
[[Fichier:P16_tableauCaptForce.PNG|500px|center]]
 +
 +
 +
Cela nous permet donc d’avoir en temps réel une information sur les zones touchées, ainsi que sur l’intensité de ce contact. Nous avons réussi à ajouter cette variation dans l'application. On peut maintenant voir une différence avec la pression exercée sur la personne. Pour l'effet visuel, plus le contact sera fort, plus la zone sera foncée.
 +
 +
{| class="wikitable center" style="margin: auto;"
 +
|
 +
|[[Fichier:P16_Apllication_CapteurToucheForce0.png|250px|center]]
 +
Vue de l'application et d'un capteur actif
 +
 +
|
 +
|[[Fichier:P16_Apllication_CapteurToucheForce1.png|250px|center]]
 +
Vue de l'application avec une pression exercée sur le capteur
 +
|}
 +
 +
 +
 +
Nous avons ajouté d'autres options concernant l'appel et l'envoi de SMS. Tout d'abord, l'utilisateur doit sélectionner s'il souhaite activer les appels et/ou les envoie de SMS. Il doit aussi, dans le cas où au moins l'une de ces deux options est cochée, entrer le numéro de téléphone à contacter en cas d'alerte. Ceci se fait sur une page de paramétrage sur l'application, voici un visuel de cette dernière : 
 +
 +
 +
 +
[[Fichier:P16_app_settings.png|250px|center]]
 +
 +
 +
 +
La principale option que nous avons ajoutée, est fonction permettant de faire vibrer le téléphone lorsqu'un appel se lance ou qu'un SMS va s'envoyer. Lorsqu’un capteur de force indique une valeur jugée trop élevée, l’application lancera automatiquement l’appel et l’envoi de SMS, en activant la vibration du téléphone pour avertir.
 +
 +
 +
[[Fichier:codeVibration1.PNG|500px|center]]
 +
 +
 +
[[Fichier:codeVibration2.PNG|300px|center]]
 +
 +
 +
Cependant, un problème se pose, si la personne n’a pas son téléphone directement avec elle, et que ce dernier est par exemple, dans un sac, elle ne pourra pas être avertie du lancement d’un appel ou d’un SMS. C’est pourquoi nous avons choisi d’intégrer un module vibrant directement sur le vêtement, ainsi dès qu’un appel se lance, ou qu’un SMS va s’envoyer, le module vibre sur le vêtement, de la même manière que le téléphone, prévenant ainsi l’utilisateur pour qu’il puisse agir en conséquence.
 +
 +
 +
Pour finir nous avons décidé d'améliorer le design de notre application mobile. Pour cela, nous avons utilisé le logiciel Adobe XD qui permet de créer des designs d'application mobile. Améliorer le design de l'application permet une utilisation plus agréable de celle-ci. Le design a été réalisé à l'aide d'un modèle trouvé sur un tutoriel Youtube : https://www.youtube.com/watch?v=IVE5ETGEoA4&
 +
 +
 +
=== Test du prototype ===
 +
 +
une fois que nous avons pu résoudre la plupart de nos soucis sur notre breadboard, nous avons voulu commencer à tester notre dispositif dans un vêtement.
 +
 +
N'ayant pas eu notre commande, nous avons testé nos capteurs dans un simple T-shirt pour valider une partie de notre travail. On a commencé par se mettre d'accord et valider le nombre et la position des zones de détection pour les capteurs tactiles mais aussi pour les capteurs de force. Une fois cette étape validée, on s'est occupé à représenter ces zones sur un T-shirt pour ensuite venir coudre le fil conducteur dessus.
 +
 +
Pour coudre nos zones, on pensait mettre un motif en forme de spiral. Par contre, on s'est rendu compte que des zones n'étaient pas entièrement couvertes. On a décidé de faire un motif rectangulaire.
 +
 +
{| class="wikitable center" style="margin: auto;"
 +
 +
|[[P16_zone_rectangle.png|300px|center]]
 +
Spiral rectangulaire
 +
 +
|[[P16_zone_spirale.png|300px|center]]
 +
Spiral
 +
|}
 +
 +
Pour coudre les zones, on a commencé par dessiner au crayon les endroits où on va devoir coudre. On a d'abord regardé si le fil conducteur nous posait problème ce qui n'a pas été le cas. On a pu commencer à coudre nos zones.
 +
 +
{| class="wikitable center" style="margin: auto;"
 +
|[[Fichier:P16_tshirt_couture.jpg|250px|center]]
 +
Phase de couture avec notre t-shirt test
 +
 +
|[[Fichier:P16_tshirt_zone.jpg|250px|center]]
 +
Rendu des zones établies sur le t-shirt
 +
|}
 +
 +
Une fois que les quelques zones ont été cousu, on a relié les fils conducteurs avec des câbles (soudures + isolation) que l'on a ensuite branché sur notre platine de tests. Sans porter le vêtement, on a constaté de légères perturbations. Rien de significatif car même lors de nos tests précédents, on a aussi observé des variations sur nos valeurs. Par ailleurs, il sera nécessaire de réduire l'espace entre les fils et surtout d'avoir un écartement homogène partout.
 +
 +
=== Identification du harcèlement ===
 +
 +
Pour l'identification du harcèlement, nous avons choisi de rajouter sur l'application une fonctionnalité permettant d'enregistrer par l'utilisateur des combinaisons de touches qu'il considère comme harcèlement en fonction de la tolérance de la personne. Il y a bien sûr combinaisons préétablies pour des zones considérées comme intimes.
 +
Nous utilisons également les capteurs de force pour prévenir un harcèlement. Ces capteurs indiquent une force allant de 0 à 15, nous considérons un harcèlement violent à partir de 8 indiquant que l'utilisateur est en danger.   
 +
 +
 +
Il nous reste à récupérer notre commande pour réaliser nos cartes, coudre le fil et réaliser la doublure avec des poches pour les PCB, et tester la dernière version de ce prototype sur Paul.
 +
 +
=== Synthèse Chat ===
 +
 +
Suite à l'actualité qui nous pousse à rester confiner chez nous, nous utilisons le chat de polytech pour communiquer avec les enseignants.
 +
 +
==== 1ere Synthèse ====
 +
 +
Nous avons énoncé les différents points d'avancement de notre projet ainsi que la répartition des rôles.
 +
Julien : PCB | Tanguy : Arduino | Paul : Application
 +
 +
*Partie PCB :
 +
Carte fille quasiment fini. il ne manque plus que l'empreinte du quartz.
 +
Carte mère il faut des empreintes spécifiques.
 +
 +
*Partie Arduino :
 +
Nous avons pu dire que nous avons résolu la partie "débuggage". La gestion multicouche est donc bonne.
 +
Les capteurs de force ont été rajouté dans le code. Il nous reste à voir la forme de la trame.
 +
 +
*Partie Application :
 +
Elle se fait en même temps que le code arduino pour valider nos solutions.
 +
 +
 +
==== 2eme Synthèse ====
 +
 +
* Partie Arduino :
 +
La trame a été mise en forme. Il nous reste finaliser nos tests et vérifier le bon comportement du code.
 +
 +
* Partie Application :
 +
L'application est mise à jour en fonction des modifications apportées sur la partie Arduino. Une fois que le code est fonctionnel et vérifié, on pourra terminer l'aspect visuel de l'application.
 +
 +
* Partie PCB :
 +
Petits soucis dans la conception des empreintes. Une fois ce problème réglé, le routage de la carte mère sera à faire et la partie PCB sera terminé.
  
 
===Documents Rendus===
 
===Documents Rendus===
 +
 +
Rapport : [[Fichier:ALLART_VERNIER_VIEUBLED_Rapport_projet_P16_S8.pdf]]
 +
 +
Diaporama présentation : [[Fichier:ALLART_VERNIER_VIEUBLED_Diaporam_projet_P16_S8.pdf]]
 +
 +
Codes arduino, Codes application, schémas et PCB disponible sur le git suivant :
 +
https://archives.plil.fr/tvieuble/ProjetIMA3-4_P16.git

Version actuelle datée du 5 mai 2020 à 01:21


Vidéo HD

Sommaire


Présentation générale

Description

Ce projet entre dans le cadre de la lutte contre le harcèlement. Le harcèlement contre lequel nous voulons lutter est le harcèlement physique ou bien contre des comportements qui peuvent dériver vers du harcèlement.


Le harcèlement est un phénomène très largement répandu dans notre société, particulièrement dans les soirées ou encore dans les transports en commun. Certaines personnes prétendes qu'il n'est pas possible de d'éradiquer ce phénomène. Nous souhaitons répondre à cette demande et pouvoir au moins détecter les zones où le harcèlement est plus fréquent pour pouvoir y agir en conséquence.


Le but de ce projet est dans un premier temps de concevoir un dispositif permettant de détection d'un contact entre la peau et une main ou un bras d'une autre personne avec la remontée et le suivi en temps réel des informations. Puis dans un second temps, la mise en place de ce système dans un vêtement tel une robe ou un pantalon. On peut imaginer lors d'un attouchement, l'envois d'une notification pour demander de l'aide ou pour prévenir une personne de se rendre sur place et d'agir.


Le dispositif que nous souhaitons concevoir n'est pas à destination que d'un seul type d'individu mais bien à tous, homme et femme confondus.

Objectifs

Le principal objectif de ce projet est de pouvoir lutter contre le harcèlement physique visant les hommes ou les femmes.

Pour cela, ce projet a été découpé en plusieurs objectifs que nous allons nous efforcer de respecter et d'accomplir.

  • Conception d'un dispositif sensitif pour les attouchements.
  • Visualisation de ces attouchements en temps réel.
  • Gestion des alarmes (envoie d'un SMS ou autre).

Ces premiers objectifs vont nous permettre de concevoir notre cahier des charges et par la suite nous guider dans le choix des technologies à choisir et utiliser.

Analyse du projet

Positionnement par rapport à l'existant

Pour lutter contre ce type harcèlement, certaines associations et certaines marques ont pu développé des actions anti-harcèlement (campagne de prévention/sensibilisation, slogan porté sur des vêtements,...)


Nous allons vous présenter deux concurrents vis à vis de notre projet.

Analyse du premier concurrent

"Point de contact capté"

Schweppes (Ogilvy) : The Dress for Respect

Au Brésil, 86% des femmes ont déclaré avoir été harcelées ou touchées sans leur consentement dans les boîtes de nuit. Pour remédier à cela, Schweppes fait appel à Ogilvy Brasil et présente une nouvelle campagne. La marque invite 3 femmes à porter la robe du respect, un vêtement connecté qui réagit au touché, afin de détecter un geste non-désiré. Les trois femmes se rendent en boîte de nuit pour se prêter à l’expérience. Les résultats en fin de soirée sont révélateurs avec au total 157 contacts ont été répertoriés pour seulement 3h47 de soirée.

Par le biais de cette action, Schweppes se sert de ce nombre impressionnant pour dénoncer un fait souvent difficile à aborder sur le moment. L’enseigne de boissons gazeuses souligne le simple fait qu’une femme n’est pas un objet et encourage les hommes à avoir un comportement plus courtois envers elles. Schweppes souhaite ainsi se positionner comme partenaire des bonnes soirées pour tout le monde.


Avantage Inconvénient
  • Capteur précis
  • Bonne visualisation des attouchements
  • Prise de conscience du problème
  • Pas de réel intervention
  • Aucune protection

vidéo de présentation youtube

Analyse du second concurrent

Un second concurrent peut-être un garde du corps. En effet afin d'éviter de se faire harceler au cours d'une soirée ou autre, une personne peut engager un garde du corps pour se faire accompagner et ainsi éviter tous problèmes avec des comportements non-désirés.


Les avantages d'un garde du corps sont que lors d'un déplacement ou d'une sortie dans le métro, les personnes qui viendront vers le client, seront rembarrées directement et n'importuneront pas la personne en question.


Par contre, ce système comporte des inconvénients qui ne sont pas des moindres. Un garde du corps est un service qui peut revenir cher de part la sécurité qu'il apporte. De plus, elle peut aussi être une gène dans le cas d'une soirée où l'on veut rencontrer de nouvelles personnes empêchant la discussion.


Avantages Inconvénients
  • Harcèlement pas possible
  • Prix
  • Pas de rencontre possible
  • Pas d'interaction avec le client

Scénario d'usage du produit ou du concept envisagé

Dans notre scénario d'usage, nous prenons le cas d'une jeune fille, nommée Nina, qui veut rejoindre des amis dans une soirée.

Elle porte sur elle la robe "anti-harcèlement" qu'elle va signaler à l'accueil afin de renseigner son code d'identification permettant son suivi au cours de la soirée.

La boite dans laquelle Nina se rend, est reconnue pour l'utilisation de ce type de vêtement. La boite est équipée d'une salle de surveillance possédant un système de visualisation en temps réel des vêtements intégrant le dispositif anti-harcelemnt grâce au code d'identification donné par Nina à son entrée. Au cours de la soirée, en cas d'abus, Nina va recevoir une notification lui demandant de valider si elle est actuellement victime d'attouchements. Si elle ne valide pas la notification au bout d'un certain délai, une personne interne de la boite va intervenir en sanctionnant le harceleur et en excluant de la soirée. De telles mesures s'appliquent élégamment si Nina valide la notification.

Ainsi Nina peut tranquillement profiter de la soirée avec ses amis en évitant les lieux auxquelles elle aurait pu être victime d'attouchements.

Réponse à la question difficile

A la suite de la présentation de notre sujet devant un jury d'enseignants et d'étudiants, nous avons retenu deux questions que nous allons prendre en compte dans la réalisation de se projet.

  • Comment allez vous faire pour éliminer les "bruits" et les contacts amicaux ?

-> Voir pour étalonner les capteurs et voir pour ajouter une fonction "mode silencieux".

seuil + metrique (durée repetion du contact et force + zone et déplacement si reponse inadentu) non attentionnel et attentinnel (non et problematique) lien des sénariots

  • Allez vous permettre une géo-localisation du vêtement ?

-> La géo-localisation est une option que nous pouvons prendre en compte via le smartphone.

Préparation du projet

Avant de pouvoir passer à la partie réalisation, nous devons :

  • Definir le type capteur à utiliser.
  • Definir le type de localisation.
  • Définir l'interface pour la visualisation des points de contact.

Cahier des charges

A partir de l'étude de notre sujet, nous avons pu établir notre cahier des charges.

  • Besoin Fonctionnel

Le système à concevoir doit permettre de visualiser les points de contact sur le corps d’une personne. Les informations doivent être visionnées en temps réel, nous devons donc traiter les données et les rendre disponible immédiatement.

Une interface à développer pourra être utile pour communiquer avec le système et afficher les résultats du traitement des données. Aussi, elle doit informer son utilisateur s’il est en situation de harcèlement. Nous avons fait le choix de développer une application pour smartphone Android.

  • Contraintes Techniques

Notre système comporte tout d’abord des spécificités. En effet, il sera composé d’un grand nombre de capteur pour la détection des points de contact. Il devra donc être léger, simple à porter sans gêner son utilisateur et surtout être discret.

Ensuite les contraintes de réalisation sont l’utilisation de l’environnement Arduino pour exploitation des informations délivrées par les capteurs de force. Pour le développement de l’application Android, on utilisera l’utilitaire MIT App Inventor. Un module de communication Bluetooth sera employé pour la communication entre le système et l’application.


A l'issue du semestre 6, nous devons être en mesure de présenter un prototype capable de détecter des touches, d'indiquer la zone concernée et aussi de prévenir l'utilisateur.

Choix techniques : matériel et logiciel

Matériel :

  • Arduino
  • Module Bluetooth
  • Capteur de force
  • Batterie


Logiciel :

  • MIT App Inventor 2
  • Arduino

Liste des tâches à effectuer

  • Déterminer le type des capteurs à utiliser (tactile, force, pression).
  • Tester les capteurs.
  • Concevoir du code pour intégrer les capteurs.
  • Positionner des capteurs.
  • Visualiser sur une application les points de contact sur le corps.

Calendrier prévisionnel

Le calendrier prévisionnel peut se concrétiser sous la forme d'un diagramme de GANTT.

P16 calendrier.PNG

Réalisation du Projet

Projet S6

Les différentes parties suivantes vont présenter le travail effectué pendant nos séances de projet semaine par semaine.

Semaine 5

Cette séance marque le commencement de notre projet. Avant de pouvoir coder ou encore de rechercher les composants qui nous seront utiles, nous avons, en tout premier lieu, pris connaissance du sujet. A partir de notre sujet, nous avons élaboré une première ébauche de notre cahier des charges, les objectifs à réaliser et aussi un planning prévisionnel.


La première heure s'est donc dérouler sous la forme d'un brainstorming qui nous a permis de rassembler les grandes idées du projet sans parler des fonctionnalités :

  • Que peut il apporter ?
  • Comment s'en servir ?
  • Où l'utiliser ?


A partir de ces idées, le groupe a pu se diviser en trois pour se concentrer sur :

  • la description et les objectifs (Tanguy)
  • l'analyse par rapport aux concurrents (Paul)
  • le scénario d'usage (Julien)

Semaine 6

Avant d'arriver à cette séance, nous avons finalisé la description et la définition des objectifs du projet. En effet, nous avons pu présenter aux autres groupes notre projet mais seulement du point de vue des objectifs et du scénario d'usage.


A la suite de cette séance de présentation des projets, un jury composé d'enseignants et d'étudiants nous a donné deux questions auxquelles nous allons devoir répondre. Ces deux questions avaient pour but de nous guider pour la deuxième partie du projet (réalisation).


Ces deux questions portaient sur l'étalonnage des capteurs et la géo-localisation de l'utilisateur.

Semaine 7

Cette séance fait suite à l’amphithéâtre de présentation des projets, c'est pourquoi nous n'avons pas réellement plus avancé sur le projet.


Par contre, nous avons réfléchi à des moyens techniques pour résoudre les deux questions que le jury nous avait exposé la semaine d'avant.

  • Pour la géolocalisation, il nous suffira d'utiliser celle du téléphone.
  • Pour tous les bruits que les capteurs peuvent émettre, il faudra les tester pour déterminer différentes valeurs en fonction du type de contact (caresse, tape..)

Semaine 9

A partir de cette séance, nous avons réellement pu travailler sur la réalisation du projet en lui-même.


L'ensemble du groupe s'est attelé à la recherche des différents composants nécessaires.

  • Microcontrôleur type carte Arduino.
  • Matériel de communication bluetooth.
  • Détecteur de touche ou force.
  • Composants d'électroniques (diode, résistance, ...)


Nous avons réalisé un petit fichier pour nous permettre de comparer les différents prix en fonction des fournisseurs agréés par l'école. Ainsi après avoir trouvé le matériel, nous avons transmis notre fichier aux enseignants afin de pouvoir passer commande.

P16 Tableau composant.PNG

Semaine 10 & 11

Nous avons pu faire avec notre tuteur un point sur l'avancement du projet pour connaître & identifier nos besoins mais aussi voir à quelle étape nous nous trouvions.


Avant de commencer à coder notre projet, nous avons réfléchi aux différentes méthodes de codage que nous pouvions utiliser. Une des questions posées par le jury se basait sur l'utilisation de nos capteurs de force. En effet, comment pouvons nous reconnaître un cas de harcèlement d'un cas tout à fait banal. Comment peut on différentier une dance avec un ami d'une caresse d'un inconnu ? Comment interpréter les contacts dans les transports en commun ?


Pour répondre à ces problèmes, nous avons établit différents mini-scénarios pour simplifier la partie programmation. Par la suite, nous ferons des tests sur les capteurs pour vérifier ces mini-scénarios. Aussi nous pourrons déterminer la zone d'action autour des capteurs ou encore les valeurs minimum et maximum.

"tableau des scénarios"


Nous avons donc déterminé certains critères pour identifier les différents cas de figure que nous pouvons rencontrer.

  • la répétition
  • la durée
  • la force

Semaine 12

A partir de cette séance, nous sommes passés sur la conception & la réalisation de notre projet.


Nous avons avons commencé par créer une application pour smartphone Android. Pour concevoir cette application, nous avons utilisé l'utilitaire MIT App Invertor 2. MIT est un outil pour concevoir simplement des applications Android. La conception d'une application se fait via des blocs similaires au langage Scratch. Pour la réaliser, nous avons suivit le cahier des charges que nous avons établit.


P16 Logo MIT.png


Tout d'abord, on a cherché à gérer la gestion des Appels/SMS. Pour tester et voir comment fonctionne l'envoie d'un SMS ou d'un appel, on utilise un bouton. Lorsque ce bouton est à 1, une boite de dialogue donne le choix d'appeler une personne pour obtenir de l'aide. On utilise un bloc Notifier pour générer une boite de dialogue et un bloc PhoneCall pour composer un numéro enregistré au préalable.

P16 Notif appel.PNG


Après quelques petits problèmes, nous sommes passé sur la gestion de la connexion Bluetooth entre le système et l'application. Nous avons juste ajouté un composant Bluetooth et deux boutons. l'un pour sélectionner le Bluetooth et l'autre pour se déconnecter. Un petit message permet de savoir si la liaison est bien établit.


P16 Liaison bluetooth.PNG


Nous n'avons pas pu tester cette connexion car nous ne disposons pas encore du module Bluetooth. Néanmoins elle est fonctionnelle car elle est similaire à un ancien projet de DUT.

Semaine 13

Pendant cette séance, nous avons poursuivi nos tests pour réussir à appeler une autre personne. Pour continuer sur la réception et l'envoi des données, nous envoyons toutes les valeurs des capteurs à la suite puis dans l'application, nous les décomposons pour retrouver la valeur en fonction de son capteur.

[[Fichier:]]

Nous pourrons tester l'application avec le programme Arduino à la prochaine séance, séance où nous devons recevoir les capteurs.

Semaine 14

Nous avons reçu les deux modèles de capteur commandés. La différence entre ces deux capteurs est leur taille. L'un est un carré d'une surface de 14.44 cm² et l'autre un rond de 1.32 cm². Nous pensons utiliser les capteurs carrés pour détecter les touches sur des grandes zones plutôt exposées (hanches, dos, extérieur des bras..) et les petits sur des zones où les risques de touches sont moindres (intérieur des bras, poitrine, intérieur des cuisses..).

P16 Capteur FSR01.png P16 Capteur FSR03.png


Nous avons pour tester ces différents capteurs créé un programme Arduino pour afficher différentes informations (valeur, force..) lorsque l'on touche le capteur. Le tableau suivant va synthétiser nos tests.


Tests des capteurs de force FSR
Type de contact Caresse Touche Main sérrée
Valeur en mV 250 - 400 500 - 700 > 800
Force en Newton 0 1 - 3 > 4

Semaine 17

Après nos différents tests, nous avons pu voir qu'en dessous d'une valeur de 300, on se trouve dans une plage de "bruits". Dans notre programme, nous ignorons donc toutes valeurs en dessous de cette plage.

On s'est rendu compte que notre application n'arrivait pas à prendre en compte l'activation de plusieurs capteurs en même temps.

Ensuite, nous avons mis à jour l'application et le code Arduino pour prendre en compte l'utilisation de plusieurs capteurs et la plage sans les bruits.

Semaine 18

Suite à des soucis de visualisation des touches sur l'application, nous avons repensé cette dernière mais aussi notre programme.

En effet, nous ne sommes pas arrivé à observer différentes touches en même temps. Or l'intérêt du projet se trouve là.

Nous avons donc changé notre application tout en gardant certains éléments que nous avons développé (Appel et Connexion Bluetooth). Après quelque changements, nous obtenons la vue suivante :

P16 Vue appli v1.png


Pour résoudre notre soucis, nous envoyons une seule trame de données. Dans cette trame, on peut savoir si oui ou non un capteur est activé. La trame est composé de plusieurs chiffres (1 ou 0). Sa longueur dépend du nombre de capteur. Par exemple, avec 3 capteurs, on peut recevoir la trame suivante : 011. On sait alors que le capteur 1 n'est pas touché mais que le 2 et le 3 le sont. Le gros soucis avec cette méthode est qu'elle est très lourde à traiter mais en utilisant MIT, nous n'avons pas trouvé d'autres solutions. Si un capteur est vue comme étant actif, on modifie la couleur d'un des boutons pour le rendre visible.

P16 Verif capteur touche.PNG


On peut voir dans la vidéo suivante comment on visualise les points de contact.

P16 video appli.gif

Semaine 19

Après de nombreux tests concluant sur la visualisation de nos tests, nous nous sommes consacré sur l'ajout de fonctionnalité. Nous avons donc optimisé et développé les points suivants :

  • Contrôle du temps d'une touche. Si la durée du point de contact est de 4 secondes consécutives, on transmet dans la trame un 2 qui demande à l'utilisateur s'il est en danger ou pas.
P16 duree 4sec.PNG P16 duree 4sec code.PNG


  • Rajout d'identifiant et de mot de passe. L'utilisateur doit pour accéder à l'application se connecter à l'aide de son identifiant et de son mot de passe.


P16 Login.PNG


  • Donner le droit à l'utilisateur d'ajouter des numéros de téléphone et de choisir la personne à contacter parmi une liste.


P16 video popup.gif


  • Agrémentation de l'application. Le but est de rendre l'application plus attractive et plus intuitive.

Perspective du projet

Pour la suite de notre projet, nous comptons réaliser nous même notre propre application. Aussi le prototype sera développé à plus grande échelle sur un vêtement entier. Notre système devra alors être miniaturisé pour rester discret et simple à porter. Nous comptons aussi revoir notre choix de technologie des capteurs. Nous regarderons aussi comment alerter l'utilisateur d'une situation de harcèlement (Ajout d'un vibreur).

Documents Rendus

Vous pourrez trouver dans cette partie les différents fichiers de notre projet.

  • Application Android : [[3]]


Bilan

Ce projet nous a beaucoup intéressé de part son actualité mais aussi par le développement que nous avons fait. Nous avons conçu un prototype fonctionnel répondant à notre cahier des charges. Nous avons pu concevoir une application, coder une carte Arduino et réaliser un prototype.


Projet S7

Etat du projet en début du S7

En ce début d'année, nous avons pour notre première séance du S7 fait un bilan sur l'état d'avancement de notre projet. Avec les différentes remarques que nous avons eu lors notre oral de présentation finale au S6 et lors de la petite entrevue avec nos enseignants encadrants pendant cette première séance, nous devons modifier et repenser certains points vitaux de ce projet.


Ces remarques concernent principalement notre système de détection et la méthode employée pour traiter les données.

  • La détection n'est pas parfaite. En effet, nous n'utilisons pas correctement nos capteurs de force car nous ne nous servons pas des données analogiques mais d'une information binaire afin de savoir si la personne est touchée. Or ces capteurs sont utilisés pour détecter une certaine pression et dans le cas d'une caresse (souvent le cas dans un harcèlement), nous sommes presque incapable de la détecter. Ce point critique est donc à revoir pour visualiser correctement une touche.
  • Par rapport à notre méthode de traitement des données, nous devons clairement identifier un cadre d'utilisation pour valider ou non les différents cas de figure que nous avons pensé. Mais alors comment arriver à différencier une touche tout à fait banale ou amicale d'un harcèlement sachant que la force exercée est exactement la même. Monsieur Boé nous a parlé de mettre en place le DeepLearning. Nous allons donc étudier la question.


Pour ce semestre, nous allons donc repenser notre prototype afin de proposer un véritable dispositif de détection. Dans un même temps, une équipe se concentrera à réalisation d'une nouvelle application. Et pour finir, nous proposerons une liste de matériel répondant au mieux à notre cahier des charges pour la réalisation finale de notre prototype au S8.

Amélioration du prototype

Etat de l'art
FabricKeyboard du MIT

Le FabricKeyboard du MIT est un tissu doté de différents capteurs. Il dispose de capteurs pour détecter le toucher, la proximité, les champs électriques, ainsi que les déformations telles que l’étirement.

Cette invention est intéressante, cependant son fonctionnement est assez complexe, et pour notre projet nous n'avons besoin que de détecter un toucher. C'est pour cela que nous n'avons pas retenu le FabricKeyboard, et avons fait d'autres recherches.


FabricKeyboard.jpg



En continuant nos recherches, nous avons trouvés un moyen de faire un capteur de touche avec de simples résistances et une carte Arduino.

Conception de capteur dit tactile

Afin de détecter plus précisément et efficacement les touches sur une personne, nous avons décidé de changer nos détecteurs de force avec d'autres capteurs basés sur le principe d'un écran tactile. Nous avons commencé par effectuer des recherches pour comprendre plus en détail le fonctionnement d'un tel écran. Nous avons pu voir qu'il s'agit d'une technologie capacitive fonctionnant sur la décharge du corps humain en travers une résistance symbolisée par l'écran.

Après ces recherches, nous nous sommes demandé comment mettre en place un tel système. Pour simuler ces capteurs "tactiles", nous avons découpé des bandes d'aluminium pour les fixer sur un support. Chaque bande d'aluminium est connecté à une pin d'entrée/sortie de notre arduino avec une résistance de type pull-up.


P16 montage v1.PNG
P16 schema v1.PNG


La résistance est une résistance de pull-up et la capacité correspond au capteur tactile qui est une bande d'aluminium. Un courant vient charger la résistance de pull-up. Lorsqu'on vient toucher la bande d'aluminium, le corps humain vient se décharger au travers de la résistance et ainsi peut voir que le capteur est actif.

Les premières tests étaient concluant mais nous avons pu observer que des latences survenaient lorsque deux capteurs étaient touchés en même temps et aussi lorsqu'ils s'étaient en contact.


Pour palier à ce problème, nous avons vu que nous pouvions mettre une pin commune avec nos capteurs. On utilise une pin d'envoie et une autre de réception. Le schéma de réalisation change légèrement et donne ceci.


P16 schema v2.PNG
P16 moniteur serie.PNG


On peut voir sur le moniteur série d'Arduino différentes valeurs. Pour obtenir ces valeurs, nous avons utilisé la bibliothèque CapacitiveSensor qui permet de détecter la capacité du corps humain. On a implémenté la méthode suivante pour utiliser cette bibliothèque. On fait basculer la pin d'envoi vers un nouvel état et on attend que la pin de réception change aussi d'état. Une variable est incrémentée pour calculer le temps de changement d'état. Lorsque l'on touche notre capteur, on obtient par conversion la valeur de notre capacité.

On peut voir que cette valeur est importante quand on ne touche qu'un capteur et diminue quand plusieurs capteurs sont touchés en même temps par quelqu'un. Dans le cas de figure où les capteurs sont en contact, la valeur ne dépassent pas les 1000. Ce point nous permet donc isolé ces valeurs et de donc de savoir comment gérer l'un des problème que nous avons pu évoquer lors de notre soutenance.


Cette méthode est concluante car on peut bien visualiser la touche sur un des capteurs. Pour chaque capteur, nous avons donc besoin d'une pin commune et de n pins (n est le nombre de capteurs). On peut envisager de mettre en place cette méthode. Par contre, la lenteur de l'arduino peut nous poser problème. On peut donc mettre en pratique nos cours de microprocesseur et de système pour optimiser les cycles du CPU et ainsi être plus rapide.

Intégration au prototype

Maintenant que nous avons trouvé la méthode idéale pour la détection de touche sur une personne, nous devons penser à la manière d'intégrer ce système au mieux tout en respectant les contraintes techniques de notre cahier des charges à savoir le point sur la discrétion du système.


La mise en place de bande de papier aluminium dans un vêtement n'est pas vraiment idéale et discrète. Nous allons donc réfléchi à une solution permettant d'intégrer au mieux notre nouveau système de détection.

  • Bobine de cuivre

  • Bobine de fil conducteur


  • La première idée consistait à utiliser des bandes autocollante cuivre provenant d'une bobine. Mais les soucis de cette idée sont d'une part esthétique (on peut voir ces bandes sous le vêtement, et d'autre part technique, à la long les bandes peuvent se décoller voir se déchirer.
  • La second idée nous est venu avec nos recherche sur les tissus tactiles. En effet, l'équipe ATAP de Google a réalisé le projet Jacquart qui consiste à intégrer de la technologie dans les vêtements afin de pouvoir avec des gestes répondre à un appel, écouter de la musique, lire un SMS et bien d'autres fonctions. Pour cela, ils utilisent un fil conducteur intégré au tissus. Nous allons donc nous baser sur cette solution avec des zones délimitées sur le vêtement. Chaque zone pourra donc vérifier une partie du corps avec un seul capteur tactile sur la zone en question. Bien évidement, le vêtement sera doubler pour éviter de prendre en compte la propre impédance de son corps.


  • Vue avant du corps

  • Vue arrière du corps


Pour compléter notre dispositif, nous avons décidé de conserver nos ancien capteur de force. En effet, avec les valeurs qu'ils peuvent envoyer, nous pouvons affiner l'analyse de la touche. Pour de grosses valeurs, on peut par exemple savoir qu'un ami nous fait une accolade ou quand on s'assoit. Dans le cas d'un harcèlement, on se base sur le fait que cela soit de la discrétion avec donc de petites touches faibles en intensité. On pourra donc être capable de différencier les différents cas de figure qui se présentent à nous.


Pour intégrer tout notre système dans un vêtement, nous avons vu qu'il existait des modules conçus pour une utilisation sur vêtement. Il s'agit des modules Lilypad. Le module principal est composé d'un atmega328, de 14 entrées/sorties et de 6 entrées analogiques. La carte vient s'enrichir d'autres modules comme des boutons, des Leds, un vibreur, un support de pile. Ces modules se présentent sous la forme suivante. L'avantage de ces modules est qu'ils sont très simples à intégrer et les options que nous voulons rajouter correspondent à des modules existants.

  • Module Lilypad

  • Module bouton

  • Module vibrant

  • Module support de pile

Nouvelle application

Nous avons commencé à développer notre application après les différents tests des capteurs tactiles. Pour cette nouvelle application, nous avons arrêté d'utiliser MIT App Inventor au profit du logiciel AndroidStudio. Il s'agit d'un IDE de développement basé sur Intellij. Pour commencer à utiliser ce nouvel environnement, nous avons suivi un cours provenant d'un master informatique du campus.


Le principe de l'application est le suivant :

Tout d'abord nous avons un programme arduino qui détecte lorsqu'une zone du vêtement est touchée. Par exemple, si la zone numéro '1' est touchée, le bit numéro '1' de la trame de donnée bluetooth prend la valeur 1 (1 = touche / 0 = pas de touche). Ensuite, on envoie la trame complète au téléphone par liaison bluetooth, et sur l'application Android on traite les données. On regarde quels bits sont à '1', et on affiche les zones correspondantes sur l'interface graphique. En parallèle avec l'affichage graphique, on lance un Timer pour chaque capteurs afin d'afficher le temps de touche par zone, ainsi que le temps total de touche toutes zones confondues. Ces différents Timers permettent ensuite d'avoir un aperçu des zones qui sont le plus souvent touchées.

D'autres fonctionnalités sont aussi présentes : l'une d'entres-elles est l'envoi d'un SMS ou l'appel d'une personne. L'utilisateur peut choisir d'activer l'envoi de SMS, ou l'appel, à un numéro préalablement enregistré dans une page de configuration. Cette fonctionnalité s'effectue alors si la personne se sent en danger.


SchemaFoncAppli.png


Connexion au Bluetooth

Pour commencer, nous avons établit la liaison Bluetooth entre l'arduino et la nouvelle application. On a tout d'abord déclarer deux permissions, une pour effectuer la communication et se connecter et l'autre pour récupérer des informations de l'utilisation telles que la localisation. 

<uses-permission android:name="android.permission.BLUETOOTH"/>
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>

Après avoir initialisé l'application, la fonction initiaBluetoothProcess() vient établir la liaison avec le module Bluetooth. Les informations envoyées et reçues sont stockées à partir de la fonction ConnectedThread().

P16 bluetooth connexion.PNG


Nous avons aussi pris le temps de développer une fonction permettant d'annuler la connexion Bluetooth.

Appel et SMS

Nous avons ajouté comme fonctionnalité le paramétrage pour prévenir ou demander de l'aide. On peut choisir entre émettre un appel et envoyer un SMS avec le numéro de notre choix. Nous avons pensé à sauvegarder le choix car nous avons vu que lorsque l'on quittait l'application, le numéro de téléphone n'est pas enregistré. Il fallait donc le noter à chaque utilisation ce qui n'est pas vraiment pratique.


P16 appel sms.PNG


P16 sauvegarde donnees.PNG


Aussi nous avons mis en place un moyen de prévenir quelqu'un lorsque l'on se sent en insécurité. Pour prévenir une personne suivant le choix fait dans les paramétrages de l'application, lorsque l'on appuie cinq fois sur un intervalle de temps de 0,5 secondes l'appel ou le sms est automatiquement envoyé. On peut alors penser envoyer seulement un sms avec les informations de localisation pour recevoir de l'aide.

Partie Graphique

Avec AndroidStudio, on pouvait à l'aide d'un simulateur voir en direct les modifications que l'on effectuait ce qui nous a été très pratique pour la conception graphique de cette dernière.

P16 graphique.PNG


On a donc créé plusieurs pages pour pouvoir :

  • Se connecter au Bluetooth.
  • Visualiser son corps et les touches
  • Paramétrer le numéro de téléphone et choisir entre SMS et Appel
  • Voir les détails des touches en temps ou en pourcentage.

Une fois que nous avons compris la méthode de conception, il nous était simple de la dupliquer pour en faire d'autres.


Les fonctions de bases ont été codé avec succès. Il ne nous reste plus grand chose à faire du côté de l'application. On peut ajouter une page de connexion avec un login et un mot de passe, choisir les informations à envoyer par SMS, un mode silencieux pour désactiver pendant une durée définie ou indéterminée. On prévoira aussi une nouvelle phase de design pour rendre l'application plus attractive et simple d'utilisation.

Nouvelle liste de matériel et explication de nos choix

A la suite de nos tests, nous pouvons donc concevoir une nouvelle liste de matériel nécessaire pour la réalisation de notre prototype final au S8 sachant que nous devons réaliser :

  • Un PCB avec arduino, composants passifs (résistance, condensateur, ...), borniers, et module vibrant
  • Notre prototype avec capteurs de force et zone avec fil conducteur

Concernant l'arduino, nous avons besoin de :

  • 6 pins analogiques pour les capteurs de force.
  • 2 pins digitales pour la liaison Bluetooth.
  • 14 pins digitales + 2 pins communes pour les zones tactiles.
  • 1 pin digitale pour un module vibrant.
  • 1 pin digitale pour un bouton.

Soit au total 6 pins analogiques et 20 pins digitales. Nous ne retenons pas la solution des modules Lilypad car le nombre d'entrées digitales est trop juste. De plus, la solution d'un PCB va nous permettre d'avoir une carte encore plus fonctionnelle et répondant parfaitement à nos besoins.


Pour le PCB :

  • Un arduino micro
  • Résistances CMS de 10MΩ | 0603
  • Capacités CMS de 0.33µF | 1206
  • Capacités CMS de 0.1µF | 1206
  • Un régulateur de tension CMS LM7805MPX si on intègre directement un microcontrôleur sur le PCB
  • Borniers


Pour le prototype :

  • Bobines de fils conducteur.
  • 2 capteurs de force FSR02CE.
  • 10 capteurs de force FSR402S.
  • Module Vibrant.
  • Bouton discret.

Objectif au S8

Maintenant que nous savons comment réaliser notre système, il ne nous reste plus qu'à le mettre en place et de trouver la bonne méthode d'exploitation des données. Nous n'arrivons pas bien à voir comment développer le DeepLearning avec notre projet mais avec les différents capteurs et les scénarios, nous pensions avoir trouvé un début de solution.


Pour le S8, nous allons donc :

  • Concevoir un PCB | 1 personne | 2-3 séances
  • Souder les composants à notre PCB | 1 personne | 1 séance
  • Définir et mettre en place les capteurs | Le groupe pour bien les définir et 1 personne pour la mise en place | 1 séance
  • Ajouter le reste des fonctionnalités sur l'application | 2 personnes | 2 séances
  • Terminer la partie graphique de l'application | 1 personne | A la fin
  • Ajouter la méthode de traitement des données | 1-2 personnes | Toutes les séances
  • Tester le prototype final avec tous les éléments ou partiellement | Le groupe après chaque modification | Toutes les séances

REF

https://dam-prod.media.mit.edu/x/2017/06/15/paper0066.pdf

https://www.media.mit.edu/projects/sensorknits/overview/

https://www.media.mit.edu/research/?filter=everything&tag=wearable-computing

Documents Rendus

Projet S8

Pour continuer notre projet au S8, nous avons trois objectifs.

  • Concevoir et réaliser un PCB.
  • Programmer notre système de detection.
  • Finaliser l'application.

Modification du système

En ce début de semestre, nous avons pris une décision qui va modifier notre dispositif. Avec de grandes zones à couvrir sur le corps, nous avons besoin d'un grand nombre d'entrées digitales et analogiques. Nous pensons créer un PC à partir d'un atmega 2560. En effet, ce microcontrôleur dispose de 54 pins digitales et de 16 pins analogiques.

Mais ce dispositif a de nombreux inconvénients :

  • Le système est central et la longueur des différents câbles va apporter des perturbations dues aux impédances.
  • Le grand nombre d'entrées va ralentir le dispositif.


Pour palier à ce problème, nous avons repenser notre système. Nous avons eu comme idée d'implanter un système maître - esclave avec une liaison I2C.

Le maître aura un rôle de récepteur et les esclaves seront les transmetteurs. A chaque instant, les esclaves enverront les informations des capteurs via une trame au maître qui analysera ces données. Si la situation est dangereuse, il demandera à un esclave d'actionner un moteur vibrant et dans le temps, il enverra un SMS ou un appel pour prévenir quelqu'un du danger.

P16 systeme synoptique.PNG

Nous avons donc décidé d'assigner une zone du corps à un seul esclave, cela permettra de pouvoir couvrir une plus large zone qu'avec notre idée initiale. Aussi, grâce à ce nouveau système, il devient plus modulable. La carte des esclaves sera généralisée pour pouvoir être disposé à n'importe quel endroit. On peut ajouter ou supprimer des capteurs plus facilement selon la personne. Par contre, les différents changements devront être pris en compte sur l'application.

PCB

Après avoir modifié notre système, on va pouvoir réaliser notre PCB avec ALTIUM DESIGNER.

Au début, nous pensions utiliser une atmega 2560 mais après réflexion et découverte d'une méthode maître - esclave, nous avons choisi de partir sur un Atmega 328p.

On aura deux PCB différents : un pour le maître et un autre pour les esclaves. Dans la conception du PCB esclave, nous avons décidé qu'ils seront tous identiques. En effet, dans le cas où l'on souhaite ajouter des capteurs sur un module pas assez précis, on va penser à prévoir la place et le matériel nécessaire pour les accueillir. Cela nous permet aussi de standardiser notre système.


Le maître sera composé de :

  • Un Atmega 328p.
  • Un régulateur de tension.
  • Un module Bluetooth.
  • Des pins pour le téléversement.


Et les esclaves seront composés de :

  • Un Atmega 328p.
  • Capteurs capacitifs.
  • Capteurs de forces.
  • Un module vibrant (Seulement pour un seul).
  • Des pins pour le téléversement.


Au départ nous avons choisi d'intégrer un bouton pour que l'utilisateur puisse valider des demandes ou signaler un problème. Mais pour des soucis d'encombrement mais aussi d'efficacité, on a choisi de le remplacer par une séquence de détection sur les capteurs de touche. En effet, dans le feu de l'action, la personne n'arrivera pas forcément à trouver le petit bouton pour demander de l'aide. Il sera donc plus facile de demander de l'aide.

Les esclaves seront donc déportés du maître et proches de leur zone afin d'éviter les impédances et les erreurs de détection. On réalise les PCB suivant les différents câblages que nous avons effectués sur notre breadboard. Pour se donner une idée sur le positionnement des composants, on suit d'abord les règles de base (condensateur au plus près, taille des pistes et espacement entre piste et composant). Pour finir, on vient ajouter un plan de masse.

Grâce aux dernières remarques de Monsieur Boé, nous avons ajouté les résistances de pull up sur le bus I2C et aussi une autre résistance sur la pin Reset et entre le quartz.


Gestion des empreintes

Après la conception des schémas électriques, nous avons pu voir que certaines empreintes n'étaient pas disponibles. Il a donc fallu recréer ces différentes empreintes (Quartz | Régulateur de tension | Connecteurs d'entrées/sorties). Grâce aux datasheets, on va pouvoir réaliser nous-mêmes les empreintes que ce soit pour le schéma ou pour le PCB.

Grâce à de nombreux tutoriels et aux documents de l'école, on vient suivre la procédure pour créer un composant dans Altium.

  • Dans le cas d'un composant sans empreinte, on vient ajouter au projet une librairie PCB. Ensuite, on dessine son empreinte. On commence par ajouter une pastille, on adapte sa taille aux dimensions voulues puis on la duplique en fonction du nombre de pattes sur le composant. Pour placer nos pastilles, on va travailler par symétrie. On se base comme si le composant était centré sur (0,0) et on vient disposer la pastille à sa position avec les données de la datasheet. On doit aussi ajouter l'encombrement du composant. Il ne nous reste plus qu'à assimiler cette empreinte au bon composant. Dans les propriétés du composant, on vient ajouter la librairie avec notre empreinte dans la partie [] en cliquant sur add.
  • Si nous n'avons pas le composant dans une bibliothèque, il faut ajouter une librairie schématique, puis dessiner le composant symboliquement et enfin créer l'empreinte en suivant la même méthode décrite précédemment.

Il est important aussi de faire correspondre les différents chaque pin à sa pastille correspondante. Lorsque les modifications sont fini, il ne faut pas oublier de réactualiser le PCB. Il ne reste plus qu'à relier le composant au reste du PCB.

P16 composant perso schematic.png

Vue schématique des composants créés

P16 composant perso pcb.png

Vue PCB des composants créés

Quartz

Le quartz est un composant simple à réaliser. Dans la datasheet, on retrouve les informations sur la taille du composant. Il nous est donc facile de recréer son empreinte. Celle-ci ne comprend que deux pastilles de même taille et opposées par simple symétrie. Lorsque l'on a fini de générer son empreinte, on obtient ces vues que l'on peut directement intégrer dans notre schéma.


P16 dimension quartz.PNG

Vue dimension de la datasheet

P16 quartz schematic.png

Schéma électrique du quartz

P16 quartz pcb.png

Empreinte du quartz

Régulateur de tension

Tout comme le quartz, on suit la même procédure. On a dû par contre faire aussi bien la partie schématique que la partie PCB car nous n'avons pas trouvé de librairie avec ce composant. On n'oublie pas d'ajouter la masse commune du composant. La partie la plus longue était de comprendre les dimensions pour placer correctement les pastilles de dimensions différentes cette fois.

P16 regulateur datasheet.png

Vue dimension de la datasheet

P16 regulateur schematic.png

Schéma électrique du régulateur

P16 regulateur pcb.png

Empreinte du régulateur

Connecteurs des capteurs

Au début nous pensons utiliser de simples trous et venir souder nos fils à la carte. Mais les remarques de M.Boé nous ont permis de changer d'avis et d'utiliser plutôt des pastilles rectangulaires. Avec cela, nous sommes sûrs d'avoir une bonne connexion avec nos pistes et aussi éviter les faux contacts.

On vient créer tous les connecteurs dont nous avons besoin en fonction du nombre de pins sur chaque. Nous avons pris une pastille de 3*6 mm et l'espace entre chaque pin est adapté en fonction du besoin. Pour le capteur de force, il nous faut laisser un peu plus d'espace pour ne pas gêner la piste de +5V.

Pour les connecteurs des capteurs, nous nous sommes arrangés pour laisser une place afin de pouvoir positionner les résistances au plus près, pour gagner en place et simplifier le routage.


Aussi après avoir fini nos cartes, nous avons avons modifié la prise du module bluetooth. En effet, à l'origine, nous avons juste mis les 4 pins nécessaires mais nous avons vu que lorsque l'on viendrait souder le module sur la carte, les 2 pins extérieures seraient en contact avec le plan de masse. Nous avons donc rajouté ces deux pins à notre composant pour éviter ce problème.


P16 connecteur schematic.png

Vue schématique des connecteurs

P16 connecteur pcb.png

Vue PCB des connecteurs

Carte maître

Nous avons commencé par réaliser la carte maître. On commence par positionner notre atmega 328-p en prenant soin de bien choisir la version CMS.

Ensuite, on ajoute les capacités de découpage et la partie alimentation. On peut remarquer qu'il y a deux connecteurs alimentation sur notre schéma. Le premier correspond à l'entrée de la tension de la batterie externe et le second à la sortie du régulateur de tension. On ne voulait pas s'encombrer de plusieurs câbles à l'entrée de la batterie et d'un côté pratique et économique, on ne veut pas ajouter un régulateur de tension sur chaque carte.

Il nous reste à gérer la partie Bluetooth, ISP2 et I2C. On place nos connecteurs et ensuite on relie aux pins de l'atmega.


P16 maitre schematic V2.PNG

On peut passer à la partie routage en suivant les règles que nous avons pu voir en cours et avec les documents disponibles sur le wiki. On commence tout d'abord par bien définir nos règles pour ne pas avoir de soucis à la fin de du routage. Une fois fini, on obtient la carte suivante. On a choisi de concevoir sur deux couches. Une fois tout le routage terminé, on n'oublie pas d'ajouter un plan de masse et de faire correspondre ce plan avec le nom du net (GND).

P16 maitre pcb V2.PNG

Vue PCB de la carte maître

P16 maitre pcb masse V2.PNG

Vue PCB avec le plan de masse

Carte esclave

Le développement de la seconde carte ne s'est pas avéré si différent que celui de la première. On travaille exactement de la même manière que pour la carte maître. Une fois que toutes les fonctions identiques ont été positionnées, on peut commencer à intégrer les besoins propres à cette carte.

On commence par mettre en place nos capteurs tactiles en suivant le schéma montré au S7. Sachant que nous avons choisi de positionner 6 capteurs sur chaque carte esclave, on les ajoute et on les relie à notre microcontrôleur. Ensuite on fait la même chose avec nos quatre capteurs de force.


P16 esclave schematic V2.PNG

Pour le route de la carte esclave, on procède de la même manière que celui de la carte maître.

P16 esclave pcb V2.PNG

Vue PCB de la carte esclave

P16 esclave pcb masse V2.PNG

Vue PCB avec le plan de masse

Réalisation des PCB

En attente de savoir si on peut les faire.

Programmation

Globalement, notre programme de détection reste le même par rapport au S7. Nous avons par contre adapté ce dernier pour la communication maître - esclave.


P16 Code esclave.PNG

Code des cartes "esclaves"

P16 Code maitre.PNG

Code de la carte "maître"


Pour les cartes 'esclaves', on effectue 2 boucles for, une pour chaque type de capteur (tactile et force). On stocke la valeur de chacun des capteurs dans une variable, puis on envoie cette valeur via la liaison I2C. Pour les capteurs de force, on transforme la valeur du capteur qui varie entre 0 et 1024 en une valeur qui varie entre 0 et 15. Ceci nous permet d'enregistrer la valeur de 2 capteurs de force dans un seul octet (un capteur sur les 4 bits de poids faible, et l'autre sur les bits de poids fort).


Pour la carte 'maître', on récupère les valeurs de chacun des capteurs sur chacune des cartes esclaves. Ensuite, on concatène les valeurs des capteurs de force dans une première variable et les valeurs des capteurs tactiles dans une autre variable. Pour finir, nous envoyons la trame de données par la liaison bluetooth directement sur le téléphone.


Protocole de communication Maître - Esclave

On connecte la carte maître et les cartes esclaves par la liaison I2C disponible sur les Atmega 328p. Le bus I2C permet de faire communiquer entre eux des composants électroniques très divers grâce à seulement trois fils : Un signal de données : SDA, un signal d’horloge : SCL et un signal de référence électrique : la masse. Le nombre maximal d’équipements est limité par le nombre d’adresses disponibles, 7 bits d’adressage et un bit R/W ce qui donne un total de 127 esclaves possibles. C'est largement suffisant pour notre dispositif.


Pour mettre en place ce bus, on utilise la bibliothèque Wire. On commence par initialiser la liaison avec la commande Wire.begin() dans le code du maître. Idem pour l'esclave en ajoutant son adresse en paramètre. Ensuite, la fonction Wire.requestFrom() permet au maître de demander aux esclaves les données. On se sert de Wire.read() pour récupérer cet octet. Côté esclave, on utilise Wire.onRequest() pour faire appel à notre fonction requestEvents() quand le maître demande l'état des capteurs.


Chaque carte esclave dispose de 1 à 6 capteurs tactiles ainsi que de 0 à 2 capteurs de force.

Le maître envoie une requête à chacun des esclaves pour obtenir l'état des capteurs et il envoie ensuite les données via une liaison bluetooth vers le téléphone qui dispose de l'application.

Les différents états des capteurs de chaque atmega328p esclave sont envoyés sous forme de trame d'octets de la forme suivante :

Slave1 capt force touch.JPG

Chaque esclave envoie une trame de 2 octets l’un après l’autre. L’octet de poids faible correspond la valeur des capteurs tactiles tout ou rien et l’octet de poids fort correspond aux valeurs analogiques des 2 capteurs de force allant de 0 à 15. Ensuite, le maître récupère les trames une par une et concatène les valeurs des capteurs tactiles entre-elles et fait de même pour les capteurs de forces.

Voici un exemple pour illustrer cette trame de données.

P16 exemple trame.png

On voit sur la gauche les états des capteurs de touche (ici 2 capteurs) qui peuvent prendre deux valeurs : 0 si le capteur n'est pas touché et 1 si quelqu'un touche le capteur. Sur la droite on a la valeur des capteurs de force (sur 4 bits).

Ensuite l'atmega328p maître réceptionne toutes les informations provenant de ses atmega328p esclaves et les envoie par bluetooth au téléphone :

Master capt force touch.JPG


On voit sur la gauche l'état de tous les capteurs confondus, sous forme décimale, puis nous avons la trame de données qui va être envoyée au téléphone par bluetooth. Cette trame se décompose en deux parties, tout d'abord on aperçoit le caractère 'f' qui est utilisé comme caractère de début de trame, ce caractère est suivi de l'état des capteurs de touche. Ensuite, on a une deuxième partie commençant par le caractère 'd' est qui est suivi des valeurs des capteurs de force (sur 4 bits : l'intensité de la force est mesurée sur une échelle de 0 à 15).

Téléversement sur les PCB

Etant donné que nous avons pris le choix de réaliser nos propres circuits imprimés, nous avons dû trouver une solution sur la façon d'implanter nos programmes dans nos microcontrôleurs. Pour la discrétion que doit avoir notre dispositif, nous avons choisi de ne pas mettre de prise USB. Cela nous permet de gagner de la place.

On pouvait prévoir les sorties Rx et Tx et utiliser un module annexe pour le téléversement.

Finalement, notre choix s'est porté sur une méthode qui consiste à utiliser une carte arduino comme programmateur. Il s'agit du protocole ISP. Nous avons besoin de 6 pins dont VCC et GND. Les trois autres pins sont :

  • MISO
  • MOSI
  • SCK

Le schéma suivant présente la méthode de fonctionnement de ce protocole.

P16 arduinoISP.jpg


Avec ce protocole, il nous est toujours possible d'utiliser l'IDE Arduino. La seule chose à changer est le type de programmeur. Dans [Outils] puis [Programmateur], il faut sélectionner "Arduino as ISP".

P16 arduino as ISP.png


Par contre, nous avons vu qu'il était nécessaire de laisser les pins Rx et Tx vide lors de cette manipulation. Pour les cartes esclaves, cela ne pose pas de soucis mais nous utilisons Rx et Tx pour le Bluetooth sur la carte maître. Pour palier à ce problème, nous avons ajouté un commutateur sur la carte. Quand on voudra téléverser notre programme, il suffira de changer la position ON sur OFF pour 'déconnecter' les pins au Bluetooth.

P16 ajout commutateur.png

Application smartphone

Sur l'application, nous visualisons toujours les différentes zones touchées sur le vêtement, et nous avons ajouté des capteurs de force pour visualiser l'intensité du touché.

Comme expliqué précédemment, la carte avec l'atmega328p maître envoie sous trame constituée de 2 messages, un message contenant les informations des capteurs de touche, et une seconde contenant les informations des capteurs de force.

Nous découpons ces 2 trames et stockons les informations dans des variables (côté application Android) et nous faisons un lien entre les capteurs de touche et les capteurs de force en fonction des zones.

Les capteurs de force ont une valeur entre 0 et 15, plus cette valeur est élevée, plus la pression captée par le capteur de force est intense. Le tableau ci-dessous montre les différentes valeurs que la carte esclave envoie à la carte maître en fonction du type de touche capté par le capteur de force :

P16 tableauCaptForce.PNG


Cela nous permet donc d’avoir en temps réel une information sur les zones touchées, ainsi que sur l’intensité de ce contact. Nous avons réussi à ajouter cette variation dans l'application. On peut maintenant voir une différence avec la pression exercée sur la personne. Pour l'effet visuel, plus le contact sera fort, plus la zone sera foncée.

P16 Apllication CapteurToucheForce0.png

Vue de l'application et d'un capteur actif

P16 Apllication CapteurToucheForce1.png

Vue de l'application avec une pression exercée sur le capteur


Nous avons ajouté d'autres options concernant l'appel et l'envoi de SMS. Tout d'abord, l'utilisateur doit sélectionner s'il souhaite activer les appels et/ou les envoie de SMS. Il doit aussi, dans le cas où au moins l'une de ces deux options est cochée, entrer le numéro de téléphone à contacter en cas d'alerte. Ceci se fait sur une page de paramétrage sur l'application, voici un visuel de cette dernière :


P16 app settings.png


La principale option que nous avons ajoutée, est fonction permettant de faire vibrer le téléphone lorsqu'un appel se lance ou qu'un SMS va s'envoyer. Lorsqu’un capteur de force indique une valeur jugée trop élevée, l’application lancera automatiquement l’appel et l’envoi de SMS, en activant la vibration du téléphone pour avertir.


CodeVibration1.PNG


CodeVibration2.PNG


Cependant, un problème se pose, si la personne n’a pas son téléphone directement avec elle, et que ce dernier est par exemple, dans un sac, elle ne pourra pas être avertie du lancement d’un appel ou d’un SMS. C’est pourquoi nous avons choisi d’intégrer un module vibrant directement sur le vêtement, ainsi dès qu’un appel se lance, ou qu’un SMS va s’envoyer, le module vibre sur le vêtement, de la même manière que le téléphone, prévenant ainsi l’utilisateur pour qu’il puisse agir en conséquence.


Pour finir nous avons décidé d'améliorer le design de notre application mobile. Pour cela, nous avons utilisé le logiciel Adobe XD qui permet de créer des designs d'application mobile. Améliorer le design de l'application permet une utilisation plus agréable de celle-ci. Le design a été réalisé à l'aide d'un modèle trouvé sur un tutoriel Youtube : https://www.youtube.com/watch?v=IVE5ETGEoA4&


Test du prototype

une fois que nous avons pu résoudre la plupart de nos soucis sur notre breadboard, nous avons voulu commencer à tester notre dispositif dans un vêtement.

N'ayant pas eu notre commande, nous avons testé nos capteurs dans un simple T-shirt pour valider une partie de notre travail. On a commencé par se mettre d'accord et valider le nombre et la position des zones de détection pour les capteurs tactiles mais aussi pour les capteurs de force. Une fois cette étape validée, on s'est occupé à représenter ces zones sur un T-shirt pour ensuite venir coudre le fil conducteur dessus.

Pour coudre nos zones, on pensait mettre un motif en forme de spiral. Par contre, on s'est rendu compte que des zones n'étaient pas entièrement couvertes. On a décidé de faire un motif rectangulaire.

300px|center

Spiral rectangulaire

300px|center

Spiral

Pour coudre les zones, on a commencé par dessiner au crayon les endroits où on va devoir coudre. On a d'abord regardé si le fil conducteur nous posait problème ce qui n'a pas été le cas. On a pu commencer à coudre nos zones.

P16 tshirt couture.jpg

Phase de couture avec notre t-shirt test

P16 tshirt zone.jpg

Rendu des zones établies sur le t-shirt

Une fois que les quelques zones ont été cousu, on a relié les fils conducteurs avec des câbles (soudures + isolation) que l'on a ensuite branché sur notre platine de tests. Sans porter le vêtement, on a constaté de légères perturbations. Rien de significatif car même lors de nos tests précédents, on a aussi observé des variations sur nos valeurs. Par ailleurs, il sera nécessaire de réduire l'espace entre les fils et surtout d'avoir un écartement homogène partout.

Identification du harcèlement

Pour l'identification du harcèlement, nous avons choisi de rajouter sur l'application une fonctionnalité permettant d'enregistrer par l'utilisateur des combinaisons de touches qu'il considère comme harcèlement en fonction de la tolérance de la personne. Il y a bien sûr combinaisons préétablies pour des zones considérées comme intimes. Nous utilisons également les capteurs de force pour prévenir un harcèlement. Ces capteurs indiquent une force allant de 0 à 15, nous considérons un harcèlement violent à partir de 8 indiquant que l'utilisateur est en danger.


Il nous reste à récupérer notre commande pour réaliser nos cartes, coudre le fil et réaliser la doublure avec des poches pour les PCB, et tester la dernière version de ce prototype sur Paul.

Synthèse Chat

Suite à l'actualité qui nous pousse à rester confiner chez nous, nous utilisons le chat de polytech pour communiquer avec les enseignants.

1ere Synthèse

Nous avons énoncé les différents points d'avancement de notre projet ainsi que la répartition des rôles. Julien : PCB | Tanguy : Arduino | Paul : Application

  • Partie PCB :

Carte fille quasiment fini. il ne manque plus que l'empreinte du quartz. Carte mère il faut des empreintes spécifiques.

  • Partie Arduino :

Nous avons pu dire que nous avons résolu la partie "débuggage". La gestion multicouche est donc bonne. Les capteurs de force ont été rajouté dans le code. Il nous reste à voir la forme de la trame.

  • Partie Application :

Elle se fait en même temps que le code arduino pour valider nos solutions.


2eme Synthèse

  • Partie Arduino :

La trame a été mise en forme. Il nous reste finaliser nos tests et vérifier le bon comportement du code.

  • Partie Application :

L'application est mise à jour en fonction des modifications apportées sur la partie Arduino. Une fois que le code est fonctionnel et vérifié, on pourra terminer l'aspect visuel de l'application.

  • Partie PCB :

Petits soucis dans la conception des empreintes. Une fois ce problème réglé, le routage de la carte mère sera à faire et la partie PCB sera terminé.

Documents Rendus

Rapport : Fichier:ALLART VERNIER VIEUBLED Rapport projet P16 S8.pdf

Diaporama présentation : Fichier:ALLART VERNIER VIEUBLED Diaporam projet P16 S8.pdf

Codes arduino, Codes application, schémas et PCB disponible sur le git suivant : https://archives.plil.fr/tvieuble/ProjetIMA3-4_P16.git

Récupérée de « https://projets-ima.plil.fr/mediawiki/index.php?title=IMA3/IMA4_2018/2020_P16&oldid=85041 »