IMA4 2018/2019 P9 : Différence entre versions
(→Semaine 8) |
(→Semaine 8) |
||
Ligne 720 : | Ligne 720 : | ||
Dans un second temps, nous avons codé la partie qui permet d'envoyer le fichier sur le serveur. | Dans un second temps, nous avons codé la partie qui permet d'envoyer le fichier sur le serveur. | ||
− | En partant, du code que nous avons rédigé | + | En partant, du code que nous avons rédigé en Java mais nous n'avons pas réussi à envoyer le fichier. Nous avons été confrontés à plusieurs problèmes. |
Dans un premier temps, afin qu’Android Studio reconnaisse les méthodes et les fonctions de la Classe FTP, il faut se rendre sur ce site [https://commons.apache.org/proper/commons-net/download_net.cgi] et télécharger la librairie: commons-net-3.6-src.zip. Par la suite, il faut la dézipper et placer le .jar dans le dossier de notre projet : app.libs. Pour qu'Android studio prenne en compte cette nouvelle bibliothèque, il faut d'abord lui indiquer le chemin dans le fichier build.graddle:app grâce à ce code. | Dans un premier temps, afin qu’Android Studio reconnaisse les méthodes et les fonctions de la Classe FTP, il faut se rendre sur ce site [https://commons.apache.org/proper/commons-net/download_net.cgi] et télécharger la librairie: commons-net-3.6-src.zip. Par la suite, il faut la dézipper et placer le .jar dans le dossier de notre projet : app.libs. Pour qu'Android studio prenne en compte cette nouvelle bibliothèque, il faut d'abord lui indiquer le chemin dans le fichier build.graddle:app grâce à ce code. | ||
Ligne 735 : | Ligne 735 : | ||
Puis dans un second temps, il faut inclure la bibliothèque dans les classes qui l'utilise avec la ligne suivante: | Puis dans un second temps, il faut inclure la bibliothèque dans les classes qui l'utilise avec la ligne suivante: | ||
+ | import org.apache.commons.net.ftp.*; | ||
+ | |||
+ | |||
+ | En plus des permissions que nous avons mentionnées plus haut, nous devons ajouter la permission suivante: | ||
+ | '''<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />''' | ||
+ | Elle permet d'avoir des informations sur l'état du réseau, contrairement à <uses-permission android:name="android.permission.INTERNET" /> qui permet de se connecter à internet. | ||
+ | |||
+ | À présent, nous avons tout ce qu'il nous faut pour envoyer notre fichier sur le serveur. Nous nous sommes ensuite basés sur notre cours de PSR, pour réaliser la suite. En effet, pour envoyer un fichier sur un serveur, il faut utiliser la programmation multi threade. Voici la fonction pour se '''connecter au serveur.''' | ||
+ | |||
+ | private void connectFTP() { | ||
+ | final String serveur ="ftp.myftpserver.com"; | ||
+ | final String login = "mylogin"; | ||
+ | final String mdp = "mypassword"; | ||
+ | new Thread(new Runnable() { | ||
+ | public void run() { | ||
+ | boolean status = ftpclient.ftpConnect(serveur, login, mdp, 21); | ||
+ | if (status) { | ||
+ | Log.d(TAG, "Connection Réussie"); | ||
+ | } else { | ||
+ | Log.d(TAG, "Connection Ratée"); | ||
+ | } | ||
+ | } | ||
+ | }).start(); | ||
+ | } | ||
+ | |||
+ | Les threads sont différents en JAVA et en C, le code ci-dessus. Pour comprendre le fonctionnement des Threads en Java, nous avons visité ce site [http://tutorials.jenkov.com/java-concurrency/creating-and-starting-threads.html]. | ||
+ | |||
+ | Enfin la fonction pour '''envoyer le fichier:''' | ||
+ | |||
+ | public boolean ftpUpload(String chemin, String NomFichier, String NomDossier, Context context) { | ||
+ | boolean status = false; | ||
+ | try { | ||
+ | FileInputStream fileStream = new FileInputStream(chemin); | ||
+ | status = mFTPClient.storeFile(NomFichier, fileStream); | ||
+ | fileStream.close(); | ||
+ | return status; | ||
+ | } catch (Exception e) { | ||
+ | e.printStackTrace(); | ||
+ | Log.d(TAG, "upload failed: " + e); | ||
+ | } | ||
+ | return status; | ||
+ | } | ||
==Semaine 9== | ==Semaine 9== |
Version du 18 mars 2019 à 22:34
Sommaire
- 1 Présentation générale : Spider and i
- 2 Analyse du projet
- 2.1 Positionnement par rapport à l'existant
- 2.2 Scénario d'usage du produit ou du concept envisagé
- 2.3 Questions difficiles
- 2.4 Réponse à la question difficile
- 2.4.1 Comment gérer l’autonomie du téléphone ? Et celle du bracelet ?
- 2.4.2 Quelle est la fréquence d’envoi des messages de notre application ? Du bracelet ?
- 2.4.3 Comment fonctionne le capteur de sudation ?
- 2.4.4 Trouver, envisager une solution de secours au cas où les parties qui ne nous concernent pas n'aboutissent pas
- 3 Préparation du projet
- 4 Réalisation du Projet
- 5 Documents Rendus
Présentation générale : Spider and i
Encadrants : Fabien Zocco / Thomas Vantroys
Eleves : Lina Mejbar / Nestor Martinez
Description
Deux hexapodes (robot à 6 pattes pouvant évoquer une grosse araignée mécanique, dimensions : 36,83 cm (L) x 43,18 cm (l) x jusqu'à 13,34 cm (h)) se font face sur un socle. Leurs interactions semblent alterner des phases de calme et de complicité, ou à l’inverse présentent des attitudes de défiance croissante voir d’agressivité manifeste. Ce jeu relationnel entre les deux robots instaure une sorte d’étrange chorégraphie artificielle, rythmée par les multiples variations de vitesses et les micro-mouvements esquissés par les hexapodes. Ces alternances et variations sont directement indexées sur le rythme cardiaque de l’artiste. Celui-ci sera, au cours des périodes d’exposition de l’oeuvre, en permanence équipé d’un bracelet connecté relevant ses données biométriques qui seront relayées via le réseau vers les deux robots.
Précisions supplémentaires concernant le sujet : Les hexapodes existent déjà. L'artiste porte (en permanence) à son poignet un bracelet connecté qui relève son rythme cardiaque ainsi que son niveau de sueur (capteur de sudation). Les données relevées à son poignet sont envoyés par bluetooth au téléphone de l'artiste. Par l'intermédiaire d'une application android, ces données sont envoyées sur un serveur web pour être récupérées par les robots équipés d'un dispositif le permettant (Raspberry).
Les araignées sont programmées pour réagir, bouger par rapport aux données qu'elles reçoivent. En fonction de si l'artiste est stressé, énervé, excité, les araignées agiront en conséquence de manière à imiter l'artiste.
Tout le travail d'analyse des données pour déterminer l'état de l'artiste est confié au laboratoire SCAlab.
La partie programmation des mouvements des araignées est effectuée par l'artiste lui-même. On pourra l'assister.
Notre travail à nous consiste à faire le lien entre le bracelet connecté et le téléphone en créant l'application nécessaire et rediriger par la suite les données sur un serveur.
Objectifs
- Etudier le langage Java pour apprendre à coder une application Android
- Apprendre à utiliser une API Bluetooth pour communiquer avec celle du bracelet
- Récupérer les données relevées par le bracelet
- Envoyer les données à un serveur web
Analyse du projet
Positionnement par rapport à l'existant
On assiste de nos jours à de nombreuses améliorations des nouvelles technologies. Donc de nombreux artistes développent ce nouveau secteur et se tournent vers de nouveaux horizons. De plus en plus d’étudiants suivent des cours de programmations dans les écoles d’arts. C’est ainsi que les artistes développent une certaine attirance pour ce domaine.
Quelques exemples :
- Adelin Schweitzer détourne des méthodes de surveillance militaire en utilisant des robots, ou des drones, contrôlés à distance proposant ainsi une nouvelle manière de découvrir des espaces urbains ou ruraux
- Dorothée Smith étude pour spectres, composé d’une caméra thermique, d’une puce électronique sous-cutanée qui implique au final un transfert de données cellulaires. Elle imagine ici une expérience limite où le moi, confronté à la menace de sa disparition, trouve dans la biotechnologie le moyen de sa résistance.
Le projet Spider&I se rapprochera du projet de Dorothée Smith mais la finalité sera différente. Notre projet à pour but final de contrôler des araignées après une récupération des données et son transfert vers une application Android.
Nous ne considérons pas vraiment de concurrence entre les artistes. Chaque artiste a sa propre vision de son projet. Il est vrai que ces artistes utilisent les mêmes outils : Capteurs, Arduino, Raspberry pi etc.
Cependant , ils trouvent une façon originale d'aboutir à un projet unique.
Scénario d'usage du produit ou du concept envisagé
Deux scénarios différents :
Scénario 1 :
---Mercredi 18 juillet 2018 de 18:30 à 22:00---
L'artiste : Fabien Zocco organise un vernissage d'exposition dans un lieu incontournable : la guinguette EP7, café/restaurant culturel. Très stressé par l'événement et par le fait de présenter son travail, son rythme cardiaque passe par des phases d'accélération et de décélération. Les données relevées par son bracelet connecté son envoyées en temps réel à notre application que nous avons conçue pour fonctionner avec deux araignées. Elles bougent sur le socle pendant tout le vernissage. Ainsi, les visiteurs peuvent visualiser à travers le comportement des araignées l'état émotionnel/psychologique de l'artiste.
Scénario 2 :
---Samedi 8 septembre 2018 de 18:30 à 22:00---
Fabien Zocco n'est pas sur les lieux de son exposition mais l'exposition a quand même lieu à EP7 dans le 13ème arrondissement de Paris, il y a probablement du public qui regarde attentivement le mouvement des araignées. Cette fois-ci les données sont envoyées avec un léger temps de latence. L'artiste passe par des périodes ou le réseau est très bon et par des périodes ou le réseau est difficile (métro). En cas de réseau difficile, les araignées liront les données d'un fichier "journée type" pour qu'elles continuent à divertir et évoluer à l'exposition.
Questions difficiles
- Comment gérer l’autonomie du téléphone ? Et celle du bracelet ?
- Quelle est la fréquence d’envoi des messages de notre application ? Du bracelet ?
- Comment fonctionne le capteur de sudation ?
- Trouver, envisager une solution de secours au cas où les parties qui ne nous concernent pas n'aboutissent pas.
Réponse à la question difficile
Comment gérer l’autonomie du téléphone ? Et celle du bracelet ?
Certaines applications sont vraiment gourmandes au niveau énergétique. Etant donné que nous souhaitons recevoir très souvent des informations du bracelet (porté par l'artiste), cela fera que notre application risque d'être énergivore. Afin d'éviter d'avoir une application trop coûteuse en énergie, nous allons permettre l'utilisation de l'application en tâche de fond. Cela nous permettra de réduire un peu la consommation énergétique de ce dernier. Nous pouvons également faire varier la fréquence de réception de données. Par exemple, on pourrait instaurer un mode "Economie d'énergie" qui permettrait d'envoyer moins de données mais sans impacter le projet. Concernant le bracelet, voici les informations concernant son autonomie en fonction de son mode d'utilisation.
- Mode partage en temps réel : 24h
- Mode d'enregistrement des données: 48h
- Temps de recharge: < 2 h
En accord avec Monsieur Zocco, nous n'avons donc pas besoin de gérer le problème d'autonomie pour la montre puisqu'il considère que son autonomie est largement suffisante.
Quelle est la fréquence d’envoi des messages de notre application ? Du bracelet ?
Nous souhaitons récupérer les données de la montre toutes les 3 à 4 minutes. Dans le cas expliqué plus haut, si le téléphone n'a plus de batterie il sera alors en mode "Economie d’énergie" et dans ce cas là les données seront reçues toutes les 30 minutes. Le bracelet est capable de faire du streaming, c'est-a-dire de l'envoi temps réel de ses données via Bluetooth ou de simplement stocker les données sur sa mémoire interne. Techniquement, il est équipé du Bluetooth Smart, le Bluetooth à basse consommation d'énergie, qui permet d'envoyer jusqu'à un Mégabit de données par secondes.
Comment fonctionne le capteur de sudation ?
Un capteur de sudation intégré dans une montre permet de suivre en temps réel, la micro transpiration des mains. En pratique c'est un patch qui est monté coté peau et qui relève le niveau de sodium et de chlorure présent dans la sueur. Ainsi, en fonction de la densité de sodium et de chlorure présents dans la sueur il est possible de déterminer avec plus ou moins de précisions, un niveau de stress. Cette information, ajoutée au rythme cardiaque, permettra de connaître l'humeur de l'artiste.
Trouver, envisager une solution de secours au cas où les parties qui ne nous concernent pas n'aboutissent pas
Pour ce qui est de la solution de secours nous dépendons de deux appareils sur ce projet : le bracelet et l'araignée.En effet, ces deux phases peuvent nous poser problème si l'artiste ne nous fournit pas le bracelet où si il y a un problème dans l’interprétation des données ou dans la programmation des données (ou si l'araignée ne nous ai pas fournie encore une fois).
Pour remplacer le bracelet, nous avons trouvé un capteur de sudation compatible arduino. Nous le connecterons à un arduino et nous ajouterons le bluetooth sur ce dernier.
Pour remplacer l'araignée, nous pourrons réutiliser des robots déjà existants à Polytech et faire en sorte que grâce à une Raspberry ils aillent lire nos données et que leurs mouvements changent en fonction.
Préparation du projet
Cahier des charges
L'artiste porte (en permanence) à son poignet un bracelet connecté qui relève son rythme cardiaque ainsi que son niveau de sueur (capteur de sudation). Les données relevées à son poignet sont envoyés par bluetooth au téléphone de l'artiste. Par l'intermédiaire d'une application android, ces données sont envoyées sur un serveur web pour être récupérées par les robots équipés d'un dispositif le permettant (Raspberry). Les araignées sont programmées pour réagir, bouger par rapport aux données qu'elles reçoivent. En fonction de si l'artiste est stressé, énervé, excité, les araignées agiront en conséquence de manière à imiter l'artiste.
Choix techniques : matériel et logiciel
Fournisseur | Quantité | Prix à l'unité (€) | Prix total (€) | URL | |
---|---|---|---|---|---|
Modules Bluetooth (802.15.1) | Mouser | 1 | 0€ | 0€ | https://www.mouser.fr/ProductDetail/Seeed-Studio/317030027?qs=wU1J8Md1npz%2f8UksA%252bh%252byw== |
Capteur de conductivité des doigts | GoTronic | 1 | 10€40 | 10€40 | https://www.gotronic.fr/art-module-de-conductivite-de-la-peau-gsr-grove-101020052-21341.htm |
Capteur de pouls | GoTronic | 1 | 22€60 | 22€60 | https://www.gotronic.fr/art-capteur-de-pouls-grove-103020024-23848.htm |
Téléphone Android | Polytech | 1 | 0€ | 0€ | |
Arduino Uno | Polytech | 1 | 0€ | 0€ | |
Total | 33€00 |
en vert : déjà donné
en gris : pas nécessaire
Liste des tâches à effectuer
Prélude : (Septembre-Décembre)
- Prise en main du sujet
- Lister le matériel nécessaire
- Discussion concernant les attentes de l'artiste
Janvier
- Apprendre le langage Java à travers différentes mises en application notamment en Tp du langage orienté objets.
- Alimenter notre Wiki
- Réfléchir à la récupération des données (API, Bluetooth ...)
Février
- Apprendre à utiliser et à maîtriser l'environnement d'Android Studio. Pour cela, regarder des cours vidéos et textuels sur internet.
- Réaliser une première version d'une application avec des fonctionnalités basiques sur Android Studio. L'application permettra de passer d'une activité à l'autre (d'une page à l'autre) et ne fera rien d'extraordinaire pour le moment.
- Alimenter notre Wiki
Mars
- Utiliser notre première version de l'application pour pouvoir l'adapter à notre sujet c'est-à-dire essayer d'y inclure la réception des données du bracelet en arrière plan par exemple.
- Gérer la réception et l'envoi des données. Pour cela nous nous inspirons de l'exemple fourni par Monsieur Zocco qui vient du Git de Empatica et qui donne un exemple d'affichage temps réel des données collectées par le bracelet.
- Apprendre à écrire des données dans un fichier en Java pour pouvoir par la suite l'envoyer.
- Assister Monsieur Zocco pour coder les mouvements des araignées (BONUS)
- Alimenter notre Wiki
Avril
- Suite du codage notre Application. Ajouter la fonctionnalité d'envoi des données stockées dans un fichier par requête HTTP.
- Faire en sorte que l'application s'utilise sans problèmes en tâche de fond (consommation énergétique faible).
- Diminuer le plus possible la consommation énergétique de l'application de manière à pouvoir l'utiliser toute la journée.
- Test des mouvements des araignées
- Alimenter notre Wiki
Mai
- Alimenter notre Wiki
- Soutenance le 6
Réalisation du Projet
Feuille d'heures
Tâche | Prélude | Heures S1 | Heures S2 | Heures S3 | Heures S4 | Heures S5 | Heures S6 | Heures S7 | Heures S8 | Heures S9 | Heures S10 | Total |
---|---|---|---|---|---|---|---|---|---|---|---|---|
Analyse du projet | 3 | 1 | ||||||||||
Design de l'Application | 2 | 3 | 1 | |||||||||
Maîtrise d'Android Studio | 3 | 5 | 4 | |||||||||
Implémentation de l'Application | 1 | 2 | 2 | 1 | ||||||||
Gestion et récupération des données | 2 | 2 | ||||||||||
Ecriture dans un fichier | 1 | 1 | 2 | |||||||||
Envoi des données vers un serveur | 1 | 2 | 3 | |||||||||
Rencontre avec M. Zocco | 1 | 2 | ||||||||||
Remplissage du Wiki | 2 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | |||
Total | 6 | 5 | 4 | 5 | 8 | 9 | 6 | 6 | 6 |
Prologue
Semaine 1
Mercredi 16 janvier 2019 :
Nous entamons la première séance dédiée au Projet du Semestre 8. Nous commençons par réfléchir à notre cahier des charges et à l'organisation de notre travail. L'objectif majeur du projet est de réussir à réaliser une application Android qui répond à tous nos besoins et qui met en lien les données relevées par le bracelet avec un serveur Web. Les araignées n'auront plus ensuite qu'à aller lire sur le serveur les données disponibles. Avant de commencer à coder, il est important que nous fassions sur papier un premier modèle, un prototype de notre application.
Réflexion sur un premier prototype d'application
Voici comment nous visualisons l'application que nous allons développer.
- Lors de l'ouverture de l'application nous pourrons visualiser le nom de notre Projet : Spider&I, suivi d'un logo que nous allons créer. Ce dernier est composé d'une araignée encerclée par un bracelet connecté, ce qui permet de représenter le contrôle qu'a le bracelet sur le mouvement des araignées.
- Le logo SOS permettra en cas de besoin pour orienter notre utilisateur, d'expliquer le fonctionnement de l'application, les différents modes d'utilisation et comment se connecter correctement au bracelet E4 Empatica.
- Le logo en bas à droite, permettra d'avoir des informations sur l'état de connexion. Il sera présent et plus utile par la suite.
- Enfin le bouton le plus important sera l'onglet Connexion qui permettra de passer à la page suivante et de se relier au bracelet E4 Empatica par liaison Bluetooth.
- Le bouton Sos sera toujours présent pour diriger l'utilisateur en cas de doute.
- le rouage en haut à gauche représente (comme souvent) le bouton de réglage et permettra à l'utilisateur de jouer sur la vitesse de transmission des données. Il pourra donc ajuster selon ses besoins/envies les paramètres des différents modes.
- L'utilisateur aura le choix entre deux modes : Temps réel qui envoie des données à une fréquence élevée permettant de faire changer le comportement des araignées en fonction de l'état actuel psychologique de l'artiste et le mode économie d'énergie qui lui envoie les données à une fréquence moins importante pour minimiser les dépenses énergétiques de l'application.
- Logo/GIF en bas au centre qui changera en temps réel en fonction de l'état de la connexion. On a imaginé un logo qui représente l'utilisateur au milieu des ses deux appareils : le bracelet et l'araignée. Quand un mode est sélectionné et que l'envoi des données s'effectue, on pourra voir un flux se déplacer entre le bracelet et l'utilisateur puis entre l'utilisateur et l'araignée. On peut imaginer que selon le mode choisi, ce flux sera plus ou moins rapide.
- Logo POWER qui permettra d'arrêter la connexion avec le bracelet si aucun mode n'est sélectionné ou bien d'arrêter l'envoi des données dans le mode sélectionné pour permettre de modifier le mode ou juste d'arrêter le transfert de données.
- On retrouve le même logo en bas à droite qui schématisera l'état de connexion du bracelet avec le téléphone, ainsi si la connexion se dégrade, il se mettra à clignoter ou changer de couleur.
Semaine 2
Pour pouvoir commencer notre projet, Mr Redon nous a donné de quoi simuler un périphérique Bluetooth. Il nous a donné :
- Module Bluetooth (802.15.1)
- Téléphone Android
- Arduino Uno.
Cela nous permettra de remplacer le bracelet temporairement.
Nous avons commencé par étudier la documentation du module Bluetooth.
D'autre part, nous avons modélisé notre l'application pensée la semaine dernière sur le site: appinventor.mit.edu
Cela nous a permis de nous introduire au langage orienté objet : JAVA. Ce logiciel permet de coder en bloc. Voici le rendu :
Semaine 3
Cette semaine, nous décidons de nous attaquer à la connexion Bluetooth au périphérique.
Pour cela nous devons :
- Afficher la liste des différents périphériques détectés à proximité.
- Donner la possibilité de cliquer et ainsi sélectionné le périphérique sur lequel on veut se connecter.
- Après sélection d'un périphérique bluetooth à portée, l'application essayera de se connecter avec le périphérique.
L'idée étant qu'une fois connecté, on puisse récupérer des données sur le périphérique.
Nous utilisons MIT Inventor 2 pour coder l'application pour le moment donc nous devons par blocks les fonctionnalités comme suit.
Semaine 4
M. Zocco nous a transmis le dépôt Git pour la manipulation du bracelet. Nous constatons que les fonctions, les classes et le code à utiliser pour gérer le bracelet est codé grâce à Android Studio.
Les fichiers sont directement accessibles sur le dépôt du Bracelet : Dépôt Git Empatica 4
Nous abandonnons alors le MIT inventor pour apprendre à utiliser Android Studio. En effet, MIT inventor ne nous permettra pas de configurer et récupérer le bracelet comme nous le souhaitons.
Nous avons passé la séance à se familiariser avec l'environnement d'Android Studio. Nous avons regardé des tutoriels sur OpenClassrooms et Youtube. L'environnement d'Android Studio est difficile à prendre en main parce qu'elle contient énormément de fonctionnalités, de méthodes qu'il faut connaître pour pouvoir les utiliser. Pourtant, tout est là mais il faut apprendre les méthodes existantes à appeler pour faire telle ou telle action.
De plus Android Studio mêle des fichiers .java et des fichiers .xml. Les fichiers xml servent principalement à l'affichage graphique et à la déclaration des variables (graphiques) tandis que les fichiers java contiennent le code exécuté par l'application elle même.
Par la suite, pour gagner du temps nous avons acheté un cours vidéo complet sur la plateforme Udemy, connue pour son contenu très riche et ses offres de cours dans tous les domaines.
Nous avons passé en temps cumulé de visionnage près de 6 heures et demi à suivre différents tutoriels de prise en main d'Android Studio et nous commençons à être à l'aise. Bien sûr le temps de visionnage n'est pas équivalent au temps passé puisqu'il est intéressant de faire en même temps ce que montre le professeur et donc de faire des pauses régulières dans les vidéos.
Voici le cours dont nous nous sommes servi ainsi que le lien : Complete Android N Developer Course
Semaine 5
Séance de projet (Mercredi 13 février)
Lors de cette séance nous avons continué le visionnage du cours concernant Android Studio. Nous nous sommes intéressés à deux chapitres qui seront très utiles dans le cadre de notre projet :
- Working with Bluetooth
- Submitting your App to Google Play
Dans le premier cours, nous utiliserons deux bibliothèques:
import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothDevice;
Voici plusieurs méthodes qui vont nous être utiles:
BA.isEnabled() vérifie que le Bluetooth de notre périphérique est bien activé grâce à la méthode BA.disable() permet de désactiver le Bluetooth Intent i = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE) nous permettra d'afficher les périphériques détectés
Afin d'afficher les périphériques connectés :
Set<BluetoothDevice> pairedDevices = BA.getBondedDevices(); ListView pairedDevicesListView = (ListView) findViewById(R.id.pairedDevicesListView); ArrayList pairedDevicesArrayList = new ArrayList(); for (BluetoothDevice bluetoothDevice : pairedDevices) { pairedDevicesArrayList.add(bluetoothDevice.getName()); }
Il faut créer une liste de pairedDevices, en utilisant la méthode getBondedDevices() qui permet de les sélectionner. Nous créons ensuite une ListView qui nous permettra de gérer l'affichage de nos informations. Nous parcourons les pairedDevices, et nous les ajoutons à la liste que nous souhaitons afficher. Par cette méthode nous pouvons utiliser la fonctionnalité bluetooth du téléphone et afficher les appareils à portée.
Pour la deuxième vidéo, elle montre étape par étape comment mettre une application créée avec Android Studio sur le Google Play Store. Nous suivons les étapes et y arrivons aussi. Cependant nous nous rendons compte que cette étape ne sera pas forcément indispensable pour nous puisque nous pourrons mettre l'application sur le téléphone directement par USB vu que le téléphone est en mode Développeur. Nous mettons de côté cette manœuvre.
Jeudi 14 février : Rendez-vous de prévu avec M. Fabien Zocco et M. Laurent Sparrow, chercheur chez SCAlab, jeudi 14 février de 10h à 12h.
Résumé des informations importantes à retenir :
- Nous devons nous concentrer sur l'énergie consommée par l'application. Par des tests, il faudra assurer que l'application fonctionne une journée entière !
- En nous aidant du Git Empatica en exemple, nous devons reproduire la réception des données mais la rendre invisible (enlever la partie affichage) pour consommer le moins d'énergie possible.
- Une fois les données récupérées, il faudra les écrire dans un fichier .JSON, .XML ou .TXT et les envoyer via une requête HTTP sur le serveur cible (FTP) fourni par M. Zocco (sous forme de quatre balises). Nous commencerons par essayer d'envoyer un fichier avec simplement écrit Hello World pour vérifier le fonctionnement.
Pour s'intéresser à la partie énergétique de l'application, il va falloir trouver un équilibre entre le taux d'échantillonnage des données (envoyées sur le serveur et reçues par la montre) et l'interface de l'application.
- Une éventuelle perte de connexion sera gérée par le programme des araignées directement.
M. Fabien Zocco et M. Laurent Sparrow, nous ont prêté un bracelet Empatica afin de pourvoir commencer un travail plus concret. Ce bracelet est normalement utilisé pour des recherches dans le domaine de la santé (par exemple : prédire l'arrivée d'une crise d'épilepsie).
Empatica propose une application sur ordinateur pour gérer le bracelet, mais pour des raisons de portabilité, nous allons créer notre application qui récupérera les données en utilisant la bibliothèque de la société.
Semaine 6
Le premier objectif lors de cette séance est d'apprendre à éditer un fichier .txt dans un programme JAVA. Une 1ère possibilité est d'utiliser la classe PrintWriter()
PrintWriter writer = new PrintWriter(mon-fichier.txt, UTF-8); writer.println(La première ligne); writer.println(La deuxième ligne); writer.close();
Une 2nde est d'utiliser la classe Files. Pour les fichiers texte, on peut alors stocker chaque ligne dans un tableau et écrire toutes les lignes en une seule commande.
List<String> lignes = Arrays.asList(La première ligne, La deuxième ligne); Path fichier = Paths.get(mon-fichier.txt);
//La commande suivante écrit les lignes en écrasant le texte déjà présent dans le fichier Files.write(fichier, lignes, Charset.forName(UTF-8));
//Pour écrire à la suite du fichier, il faut utiliser la commande suivante Files.write(fichier, ligne, Charset.forName(UTF-8), StandardOpenOption.APPEND);
Nous avons réussi à faire tourner un petit programme de création de fichier sur ordinateur mais avons rencontré des problèmes pour le faire sur l'application téléphone directement. L'application crash et s'éteint au moment de l’enregistrement du fichier. Nous pensons que c'est parce que nous avons mal géré (pour le moment) l'emplacement d'enregistrement du fichier ainsi que les droits nécessaires pour pouvoir le faire. C'est une question de temps avant que notre application puisse enregistrer son propre fichier.
Le 2ème objectif lors de cette séance est d'apprendre à utiliser Filezilla afin de pouvoir gérer l'envoi de notre fichier sur le serveur.
Nous avons trouvé un site qui nous va bien nous aider: dfarnier.fr/filezilla-manipuler-les-fichiers
M. Zocco nous a envoyé les informations nécessaires (hôte, login et mot de passe) afin d'essayer d'envoyer un fichier test helloword.txt sur son serveur. Nous allons suivre le mode d'emploi sur le site que nous avons trouvé.
C'est sur cette interface que l'on peut modifier des fichiers et les renvoyer sur le site de M. Zocco. Voici son site: http://www.fabienzocco.net/
Nous avons réussi à modifier le code du fichier test.txt qui est sur le serveur de M.Zocco. Nous allons maintenant apprendre à le faire en Java. Pour ce faire nous allons utiliser FTPClient Class de la librairie Apache Commons Net.
FTPClient client = new FTPClient(); FileInputStream fis = null; try { client.connect("ftp.domain.com"); client.login("admin", "secret"); Ici il faut renseigner les informations de M. Zocco
String filename = "Touch.dat"; fis = new FileInputStream(filename); Permet de créer un flux d'entrée
// Store file to server client.storeFile(filename, fis); Permet d'envoyer le fichier sur le serveur client.logout(); } catch (IOException e) { Vérifier qu'il n'y a pas d'erreur d'input/output e.printStackTrace(); } finally { try { if (fis != null) { fis.close();} client.disconnect(); } catch (IOException e) {e.printStackTrace();} }
Semaine 7
Cette semaine, nous travaillons séparément pour être plus efficace. Deux parties à gérer :
- La réception des données en arrière-plan. (Nestor)
- l'écriture dans un fichier pour l'envoi vers un serveur. (Lina)
1. Partie réception des données
L'objectif pour cette partie est donc de réussir à récupérer les données envoyées par le bracelet pour pouvoir les écrire dans un fichier par la suite. Nous devons donc nous inspirer de l'exemple disponible sur le git. Pour le faire fonctionner, nous suivons les instructions sur le git et nous rentrons notre API Key fournie par M. Sparrow lors de la réunion. Nous générons le fichier apk (fichier permettant l'installation de l'application) et nous l'installons sur le smartphone. Voici à quoi cela ressemble (voir Photo 1) :
On voit que toutes les informations relevées par le bracelet apparaissent à l'écran. On peut y voir la température, les coordonnées du bracelet dans l'espace grâce à l'accéléromètre etc. Cependant, cette affichage temps-réel doit être gourmand en énergie.
Pendant la réunion, nous avons décidé de minimiser les coûts énergétiques et donc de ne pas mettre d'affichage des valeurs relevées. Nous cherchons alors à avoir l'application la plus pure possible. Pour faire un exemple et vérifier que nous arrivons bien à récupérer les données nous décidons d'afficher seulement la batterie de la montrer en temps-réel. Le reste s'actualise en arrière-plan. (voir Photo 2)
Pour cela, il a fallu étudier le code du git de près pour le comprendre et pouvoir l'intégrer dans l'application. Cette étape a occupé une grande partie de la séance. Une fois le code assimilé et intégré, nous avons essayé de l'adapter pour n'afficher que la batterie. Le problème du code de l'exemple est qu'il intègre des bibliothèques empatica que nous ne connaissons pas et le bracelet donne l'impression qu'il contient déjà un programme ainsi que certains processus qui s’exécutent automatiquement. Ces derniers n’apparaissent pas dans le code donc il est difficile d'en modifier leur comportement. Par exemple, dans le code n'apparaît pas la boucle qui vérifie si les capteurs ont changé de valeur. Pourtant cette boucle existe forcément.
J'explique tout cela parce qu’en voulant sauvegarder les données dans des variables plutôt que dans de l'affichage pour pouvoir les écrire dans un fichier, la batterie ne s'affiche plus. Alors pour comprendre ce qu'il se passe, j'ai affiché dans les messages logs (invisibles pour l'utilisateur), les changements de la variable EDA qui correspond à l'activité électrodermale. Cela veut dire qu'à chaque fois qu'il change la valeur d'EDA il va afficher la nouvelle valeur dans les messages logs et voici ce que j'observe :
Je remarque qu'environ toutes les 1,5 secondes, il y a du nouveau dans les logs mais ce qui est étrange c'est que au même instant cette fonction envoie 6 variables parfois différentes en même temps. Je rappelle qu'à ce moment là je lui demande juste d'afficher dans les logs les changements sur le capteur d'EDA de la méthode didReceiveGSR. C'est comme si, la montre stockait les valeurs du capteur et les envoyait toutes d'un coup à intervalle régulier de 1,5 seconde. On dirait que la sauvegarde des valeurs dans des variables bloque l'affichage et la mise à jour de la batterie. C'est très étonnant. Pour l'instant je n'arrive pas à comprendre pourquoi ce processus est bloquant.
2. Partie écriture et envoi des données
L'objectif pour cette partie est de réussir à adapter le code que nous avons écrit la semaine passée en JAVA et de le rendre fonctionnel pour une application Android. Ce n'est pas forcément évident et c'est pas parce qu'un code fonctionne en JAVA qu'il sera utilisable et/ou adaptable pour une application mobile dans l'environnement Android Studio.
Problèmes rencontrés
En effet, le code JAVA était fonctionnel la semaine dernière, nous avons réussi à envoyer le fichier "essai.txt" sur le serveur. Notre code commence d'abord par le créer, l'ouvre, écrit "Je crée le fichier essai.txt" et fini par l'envoi sur le serveur en FTP.
Jusqu'à présent nous utilisions un émulateur Android pour essayer les applications qu'on codait. Mais étant donné que nous voulons accéder à la mémoire du téléphone, il faut générer le fichier .apk et l'installer sur ce dernier.
Lors de la séance, nous avons eu du mal générer le .apk depuis Android Studio sur Mac. Malgré le fait que la tablette soit en mode développeur, Android Studio ne reconnaissait pas l'appareil. Nous avons alors perdu beaucoup de temps puisque pour tester l'application, nous devions à chaque fois copier le fichier .apk sur une carte SD puis l'installer sur la tablette. L'inconvénient de cette méthode est que nous ne pouvons pas avoir plus d'informations sur les erreurs. (notamment l'affichage des logs, un outil indispensable qui permet de déboguer).
Code pour créer un fichier sous Android
Nous avons alors codé à l'aveugle, lorsque notre code ne fonctionnait pas, nous ne savions pas d'où venait le problème.
Le problème majeur que nous rencontrions était que notre application ne créait pas le fichier test que nous souhaitions, mais sans les logs c'était compliqué de savoir d'où venait le problème. Nous avons alors cherché sur internet. Nous avons alors vu que notre problème était récurent et pour le résoudre, il fallait rajouter la ligne ci-dessous dans le code d'un fichier du projet : Manifest.xml :
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />.
Cette ligne de code donne la permission à notre application de pouvoir écrire et créer un fichier sur l'appareil.
Voici la partie la plus importante du code qui permet de créer un fichier "fichier_info.txt" (ou de l'écraser et d'en créer un nouveau s'il existe déjà).
File textFile = new File(Environment.getExternalStorageDirectory(), "fichier_info.txt"); //création du fichier try { String text2="\n Salut "; FileOutputStream fos = new FileOutputStream(textFile); fos.write(text.getText().toString().getBytes()); // Récupérer caractères rentrés par l'utilisateur et les écrire fos.write(text2.getBytes()); // Écrire des caractères (Type String) fos.close(); Toast.makeText(this, "File Saved.", Toast.LENGTH_SHORT).show(); } catch (IOException e) { e.printStackTrace(); }
La photo 4 montre l'application que nous avons créé pour tester l'écriture de fichier. On écrit ce qu'on veut dans la boîte de dialogue et en cliquant sur le bouton SAVE FILE, le texte tapé est directement enregistré dans le fichier fichier_info.txt. La photo 5 l'illustre.
Semaine 8
L'objectif cette semaine est de réussir à mettre en lien les deux fonctionnalités travaillées la semaine passée. Pour l'instant, une seule sur les deux est fonctionnelle : l'écriture dans un fichier. Il faut régler le problème d'enregistrement dans des variables. Nous avons constaté la semaine dernière que pour certains capteurs on reçoit plusieurs valeurs d'un seul coup, il faut donc mettre en place un système de traitement efficace.
De plus, entre temps nous avons remarqué que certains capteurs ont des fréquences d'écoute plus élevées que les autres c'est-à-dire qu'ils envoient plus de valeurs (ou plus vite) que d'autres capteurs. On aura donc plus de valeurs mesurées pour les capteurs concernés.
Nous avons donc contacté notre tuteur Monsieur Zocco ainsi que Monsieur Sparrow pour se mettre d'accord sur l'organisation du fichier final. Voilà ce qui ressort de cet échange :
- le fichier final devra présenter dans l'ordre les valeurs de Température, EDA, Accéléromètre et IBI.
- il est primordial d'avoir les deux valeurs relevées par le capteur IBI pour rendre cette information exploitable. Jusqu'ici nous n'avions qu'une seule valeur.
- nous séparerons les valeurs par des /, ce sera notre séparateur ainsi que le caractère \n de retour à la ligne entre chaque capteur différent.
- le fichier comportera 30 valeurs par capteur, cela correspond environ à une valeur par seconde. Le fichier sera alors le résultat de 30 secondes de mesure.
Pour l'Inter Beat Intervalle (IBI), Laurent Sparrow nous a expliqué que ce capteur mesure le temps séparant 2 battements cardiaques, il n’y a pas de fréquence d’échantillonnage pour cet indicateur. Normalement, on doit avoir 2 colonnes : 1 pour le timestamp, et l’autre pour la valeur (en seconde) de l’IBI (temps séparant 2 battements). Pour l’interpréter, on compte le nombre d’intervalles supérieures à 50 ms par exemple. Une autre analyse consiste à analyser les bandes de fréquence concernant ces valeurs (est-ce que les variations d’IBI sont de basse, moyenne et haute fréquence), sans chercher une valeur supérieure à 50 ms pour suivre l’exemple précédant.
L'ensemble des relevés des deux données vont ensuite permettre de catégoriser l’état psychologique de Fabien Zocco, son activation etc. Ceci permettra de piloter le robot.
Le blocage de la batterie en semaine 7 n'était pas réel, c'était un bug de la montre qui n'envoyait pas la valeur de la batterie donc forcément rien n'était affiché.
Pour pouvoir écrire dans un fichier par la suite l'ensemble des valeurs d'un coup et pouvoir organiser le fichier comme souhaité, nous avons tout intérêt à stocker les valeurs reçues. Pour cela nous les stockeront dans un tableau. Chaque capteur aura son tableau de valeurs à remplir lui-même quand il en reçoit de nouvelles. Nous choisissons des tableaux statiques pour contrôler et limiter la mémoire utilisée. Par exemple :
private String [] temperatureLabel = new String[MAXVAL]; //Ce tableau contiendra les valeurs relevées de la température
Pour l'instant nous fixons MAXVAL à 10 pour effectuer quelques tests. Nous essayons donc de relever les 10 premières valeurs des capteurs de Température, d'IBI, d'EDA et d'accéléromètre. Une fois les valeurs stockées dans les tableaux respectifs et quand tout le monde a ses valeurs, nous écrivons dans un fichier les valeurs. Voici un premier essai avec seulement la température, l'ibi et l'eda : (voir Photo 1)
Le résultat est bon et proche de celui que l'on souhaite. Cependant, on remarque que les premières valeurs de la température sont erronées (très négatives) ! Nous rajoutons alors un petit bout de code pour pallier ce problème et ne pas prendre en compte les valeurs négatives. Ce n'est pas visible ici car le problème avait déjà été traité mais la première d'EDA est aussi erronée (égale à 0). Nous ajoutons aussi un autre test pour vérifier que la valeur nouvelle n'est pas identique à la précédente, de même on ne la prend pas en compte si c'est le cas. Ce dernier test est seulement pour la température et l'EDA qui envoient beaucoup plus de données que les autres capteurs. Voici à quoi ressemble le code de ces fonctions :
public void didReceiveTemperature(float temp, double timestamp) { if(tempCpt < MAXVAL && !fileReady && temp>0) { if(tempCpt == 0){ temperatureLabel[tempCpt] = String.valueOf(temp); tempCpt++; } else{ if(temperatureLabel[tempCpt-1].compareTo(String.valueOf(temp))!=0) { temperatureLabel[tempCpt]=String.valueOf(temp); tempCpt++; } } Log.i("DEBUG", "TEMP : " + String.valueOf(temp)); } if(tempCpt==MAXVAL) tempCpt=0; }
Pour le moment, le code n'est pas optimal, on s'arrête quand on a reçu 10 valeurs d'IBI (capteur le plus long à réagir). Remarque : tant qu'on n'a pas les valeurs d'IBI, la température continue de remplir son tableau et le remet à jour, on aura donc à la fin les 10 dernières valeurs de la température. L'avantage indéniable de procéder ainsi est qu'on est sûr d'avoir bien 10 valeurs pour chaque capteur à la fin tandis que si on relève les valeurs des capteurs pendant 30 secondes, peut-être qu'on aura moins de 30 valeurs pour l'IBI et plus de 30 pour la température (et l'EDA). Nous ferons en sorte par la suite de mettre en place un timer qui écrit les valeurs qu'il a reçu pendant une période précise (30 secondes ou plus) et puis nous nous mettrons d'accord avec Fabien Zocco pour qu'à l'arrivée, les araignées n'interprètent que les valeurs pertinentes.
Une fois les tests effectués et vérifiés, nous ajoutons les valeurs d'accéléromètre et voici l'état du fichier : (Voir photo 2)
Envoi des fichiers sur le serveur
Dans un second temps, nous avons codé la partie qui permet d'envoyer le fichier sur le serveur. En partant, du code que nous avons rédigé en Java mais nous n'avons pas réussi à envoyer le fichier. Nous avons été confrontés à plusieurs problèmes.
Dans un premier temps, afin qu’Android Studio reconnaisse les méthodes et les fonctions de la Classe FTP, il faut se rendre sur ce site [1] et télécharger la librairie: commons-net-3.6-src.zip. Par la suite, il faut la dézipper et placer le .jar dans le dossier de notre projet : app.libs. Pour qu'Android studio prenne en compte cette nouvelle bibliothèque, il faut d'abord lui indiquer le chemin dans le fichier build.graddle:app grâce à ce code.
dependencies { implementation 'com.android.support:support-v4:18.0.0' implementation files('libs/commons-net-3.3.jar') } repositories { flatDir { dirs 'app.libs' } }
Puis dans un second temps, il faut inclure la bibliothèque dans les classes qui l'utilise avec la ligne suivante:
import org.apache.commons.net.ftp.*;
En plus des permissions que nous avons mentionnées plus haut, nous devons ajouter la permission suivante:
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
Elle permet d'avoir des informations sur l'état du réseau, contrairement à <uses-permission android:name="android.permission.INTERNET" /> qui permet de se connecter à internet.
À présent, nous avons tout ce qu'il nous faut pour envoyer notre fichier sur le serveur. Nous nous sommes ensuite basés sur notre cours de PSR, pour réaliser la suite. En effet, pour envoyer un fichier sur un serveur, il faut utiliser la programmation multi threade. Voici la fonction pour se connecter au serveur.
private void connectFTP() { final String serveur ="ftp.myftpserver.com"; final String login = "mylogin"; final String mdp = "mypassword"; new Thread(new Runnable() { public void run() { boolean status = ftpclient.ftpConnect(serveur, login, mdp, 21); if (status) { Log.d(TAG, "Connection Réussie"); } else { Log.d(TAG, "Connection Ratée"); } } }).start(); }
Les threads sont différents en JAVA et en C, le code ci-dessus. Pour comprendre le fonctionnement des Threads en Java, nous avons visité ce site [2].
Enfin la fonction pour envoyer le fichier:
public boolean ftpUpload(String chemin, String NomFichier, String NomDossier, Context context) { boolean status = false; try { FileInputStream fileStream = new FileInputStream(chemin); status = mFTPClient.storeFile(NomFichier, fileStream); fileStream.close(); return status; } catch (Exception e) { e.printStackTrace(); Log.d(TAG, "upload failed: " + e); } return status; }