IMA4 2017/2018 P22

Présentation générale

Notre projet consiste à étudier le fonctionnement d'une horloge connectée réalisé par des secondes, en vue de l'améliorer ou d'y ajouter des fonctionnalités. L'horloge servira de serveur de temps et diffusera la date sur les ordinateurs de la salle de projet. Un utilisateur pourra interagir avec elle pour afficher par exemple l'actualité ou jouer à un jeu vidéo.

Description

L'horloge sur laquelle nous travaillerons possède plusieurs fonctionnalités actuellement:

• Elle reçoit l'heure par onde radio depuis l'Allemagne via protocole DCF77.
• Elle affiche l'heure sur une matrice de LED.

Le but de notre projet est de lui ajouter des fonctionnalités supplémentaires en vue de la rendre plus interactive avec le ou les utilisateurs.

L'horloge est principalement constituée d'une Rasperry Pi et de 2 matrices de LED. La Raspberry nous permettra de rajouter la plupart des fonctionnalités.

Objectifs

• Installer un serveur de temps NTP.
• Améliorer la réception DCF77.
• Protéger le système contre les coupures de courant ou les débranchements inopinés.
• Trouver une application à la 2e matrice de LED.
• Faire interagir l'utilisateur avec l'horloge (personnalisation de l'affichage, jeu-vidéo).
• Gérer les fuseaux horaires.

Analyse du projet

Positionnement par rapport à l'existant

Le marché des objets connectés est en plein essor. Il est donc naturel que beaucoup de produits sont très semblables au notre, en effet il n'en manque pas :

• Montre connectée : se porte au poignet, accès aux réseaux sociaux, aux sms, aux appels téléphonique, etc.
• Réveil connectée : réveil comme fonction principale, affiche la météo, affiche des rappels.
• Horloge connectée : affiche des rappels, la météo, les grands titres de l'actualité.

Analyse du premier concurrent

LaMetric

Caractéristique :

• matrice de led 37x8
• connecté au smartphone en wifi
• ajout de fonction via un store
• électriquement dépendent
• orientation réseau sociaux
• synchronise son heure via serveur LaMetric

Exemple de fonctionnalité : Météo , compteur de “j’aime / abonnée” ,Domotique , ...

Analyse du second concurrent

Glance Clock

• Affichage de l’heure
• Réveil et chronomètre
• Sonorisations
• Rappels
• Appels téléphoniques entrants et sortants
• Afficheur météo
• Calendrier compatible Google, Microsoft, etc.
• Affiche diverses informations dans le cas d’une maison connectée

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

L’utilisateur entre dans la salle où se trouve l’horloge, elle est accrochée à un mur. Si elle n’est pas allumée, il la branche et actionne un interrupteur. L’heure s’affiche automatiquement.

Cas “ludique” :

L’utilisateur a quelques minutes à perdre. Il lance le jeu depuis son smartphone android. Le jeu se lance sur la deuxième matrice de LEDs. Son téléphone fait office de manettes. Il joue et essaie de battre le score des personnes ayant joué précédemment.

Cas “informations” :

L’utilisateur souhaite suivre les nouvelles en temps réel. Il configure la deuxième matrice de LEDs en se rendant sur une application web accessible via tout support possédant un navigateur internet. Sur l’application web il indique l’adresse d’un ou plusieurs sites d’actualités ou disposant d’un flux (RSS par exemple). La deuxième matrice de LED fait défiler les titres de l’actualité. Quand il veut éteindre l’horloge, il actionne l’interrupteur, celle-ci s'éteint correctement. En cas de coupure de courant l’horloge s’éteint aussi correctement grâce à l’appui énergétique d’un accumulateur.

Réponse à la question difficile

Question: Comment gérer les différents fuseau horaire ainsi que les décalages horaires heure été / heure d'hiver ?

Solution envisagé : Choix du fuseau horaire à l'initialisation de l'horloge ( choix par pays), questionnement d'une base de données qui fait correspondre le pays au fuseau horaire.

Préparation du projet

Cahier des charges

• Réception de l'heure par onde radio DCF77 (77.5 kHz)
• Ajout d'un jeu sur la 2e matrice de LEDs
• Ajout d'un bandeau d'information sur la 2e matrice de LEDs
• Ajout d'une batterie à la Raspberry Pi pour effectuer une extinction propre en cas de coupure de l'alimentation
• Mise en place d'un serveur NTP sur l'horloge

Choix techniques : matériel et logiciel

Application mobile :

• Programmée en Java avec Android Studio

Liaison mobile/horloge :

• Technologie Bluetooth, la personne qui interagie avec l'horloge sera forcément à proximité.

Extinction propre :

• Batterie rechargeable.
• Contrôleur de batterie.

Réception DCF77 :

• Module BN 641138

Liste des tâches à effectuer

• Configurer l'heure de la raspberry sur l'heure DCF77
• Créer l'application mobile (manette)
• Créer le jeu et l'afficher sur la 2e matrice de LEDs
• Mettre en place l'extinction propre (batterie)
• Mettre en place le serveur NTP

Réalisation du Projet

Matériels nécessaire

une batterie pour alimenter la raspberry en cas de panne électrique: 4,8 v | 500mAh lien : http://fr.farnell.com/varta/55750404014/pack-de-batterie-nimh-510mah-4/dp/1903286

un contrôleur permettant d'assurer une charge autonome de la batterie : https://fr.rs-online.com/web/p/controleurs-de-charge-de-batterie/5456852/

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
DCF77			4	4						4
Analyse du projet	15
Panneau de Led : Texte défilant									12
Serveur Bluetooth									2
Application Bluetooth								8	12
Carte électronique batterie											4

Prologue

• Recherche sur les systèmes existant.
• Analyse du fonctionnement de l'antenne DCF 77
• Réponse à la question "difficile" .

Semaine 1

• Analyse du matériels nécessaire :

Batterie permettant à la Raspberry en cas de coupure électrique. Calcul de la puissance instantané consommée par l'horloge.

	Raspberry	Panneau LED	Antenne	Total
Consommation	4 W	2 x 10 W	0,015 W	24,015 W

On choisit une batterie avec 5 min d'autonomie (largement le temps d'extinction de la raspberry) sois environ 2Wh la raspberry s'alimente entre 4,5 et 5,7v , nous avons choisit une batterie de 4,8 v et 500 mah. La charge de la batterie est gérée par un contrôleur MicroChip.

• Décision sur l'interaction utilisateur/horloge

Après avoir comparé les avantages et inconvénients de l'application web et de l'application mobile, nous avons choisi de réaliser une application mobile. Celle-ci communiquera par bluetooth avec l'horloge. Il est inutile qu'elle communique par internet étant donné que les interactions se feront à proximités de l'horloge. L'application mobile sera sur Android et sera développée en Java avec Android studio.

Information la configuration de la raspberry:

Wifi :

     nom :  HorlogeICN
     mdp : fenelonlille

Wlan0 :

      address : 192.168.100.1

Eth0:

    address : 192.168.0.42
    gateway : 192.168.0.1

Semaine 2

Le horloge n'affiche pas l'heure correcte. Le problème peut venir d'une mauvaise réception , perturbation ou du programme qui récupère l'heure.

on commence par l'analyse du programme de récupération de l'heure.

Le message de la 2e matrice de LED est modifiable via le fichier /var/www/html/index.php. Celui-ci écrit le message dans le fichier "message". On suppose ensuite que "message" est ouvert par le programme "horloge" qui se charge d'envoyer les 2 lignes sur la matrice de LED.

Semaine 3

Le récepteur intégré à l'horloge est trouvable sur le site du revendeur "Conrad". Sur ce site nous avons trouvé une doc sur la connexion des fils au module mais pas de datasheet sur le module électronique nommé BN 641138 qui se charge de transformer le signal en bit.

Le signal DCF77 est envoyé depuis une antenne en Allemagne à Mainflingen (près de Francfort-sur-le-Main) par le Physikalisch-Technische Bundesanstalt (PTB). Le signal de fréquence 77.5 kHz est envoyé à une puissance environnant les 30 kW. L'information est numérique et modulée semblable à une OOK. Une trame dure 60 secondes, chaque secondes correspond à un bit :

L'information est codée sur un abaissement de l'amplitude pendant une durée donnée. Pour signifier un 1 ou un 0, l'amplitude est de 15% sa taille maximale. Un bit 0 correspond à un changement d'amplitude pendant 100ms, pour un bit 1 c'est 200 ms.

Décodage de la trame :

Un trame de 60 seconde est constitué des informations suivantes :

 Bit0 :                Début de trame (bit à 1).
 Bit1 à 14 :        Réservé pour une utilisation future.
 Bit 15 :                Bit d'antenne (0 = antenne normal 1 = antenne de réserve)
 Bit 16 :                Changement heure d'hiver/heure d'été (1= passage heure été/hiver)
 Bit 17 :                0: inactif / 1: heure d'été (GMT+2)
 Bit 18 :          0: inactif / 1: heure d'hiver (GMT+1)
 Bit 19 :                1 quand une minute de 61 secondes est insérée
 Bit 20 :                Bit de début (start) (Toujours à 1)
 Bit 21..27 :        Valeur des Minutes ( Bit: 21 = 1, 22 = 2, 23 = 4 , 24 = 8 , 25 = 10 , 26 = 20, 27 = 40)
 Bit 28 :                Parité pour tous les bit transmis minutes (Bit de parité paire)
 Bit 29..34        Valeur des heures ( Bit: 29 = 1, 30 = 2, 31 = 4 , 32 = 8 , 33 = 10 , 34 = 20)
 Bit 35 :                Parité pour tous les bit transmis heures (Bit de parité paire)
 Bit 36..41 :        Valeur du jour ( Bit: 36 = 1, 37 = 2, 38 = 4 , 39 = 8 , 40 = 10 , 41 = 20)
 Bit 42..-44 :        Valeur du jour dans la semaine (  Bit: 42 = 1, 43 = 2, 44 = 4)
 Bit 45..49 :        Valeur du mois ( Bit: 45 = 1, 46 = 2, 47 = 4 , 48 = 8 , 49 = 10)
 Bit 50..57 :        Valeur de l'année ( Bit: 50 = 1, 51 = 2, 52 = 4 , 53 = 8 , 54 = 10 , 55 = 20, 56 = 40, 57 = 80)
 Bit 58 :                Parité pour tous les bit transmis date (Bit de parité paire)
 Source : http://s159401799.onlinehome.fr/600HorlogeAtomiqueDCF77.html

Branchement du module de réception sur la Raspberry Pi

Nous avons installé RaspBian Jessie sur une seconde Raspberry Pi pour pouvoir faire nos test de réception et coder les programmes nécessaire au projet. Ces programmes pourront ensuite être transférés sur la Raspberry Pi du projet.

Raspberry PI n°2

    IP salle E304 :"172.26.145.183"

Pour récupérer les bits du module BN 641138, nous allons utiliser la bibliothèque C, wiringPI. Elle permet de faciliter l'accès aux GPIOs des RaspberryPi.

Le module, demandant très peu de courant peu être alimenté par la Raspberry Pi, nous branchons sont alimentation sur la pin 3.3 Volts et la pin non inverseuse sur le GPIO 17.

Nous avons installé python pour pouvoir rapidement observer un signal à l'aide d'un petit programme trouvé sur internet. Celui-ci n'a pas voulu fonctionner.

• Test GPIOs python : https://pythonhosted.org/RPIO/#documentation
• Comment utiliser le GPIOs http://s159401799.onlinehome.fr/600HorlogeAtomiqueDCF77.html

Semaine 4

Lundi : Test du récepteur BN 641138 (récepteur DCF77). Nous nous sommes documentés sur comment recevoir correctement le signal DCF77. Globalement les utilisateurs de ce modules n'ont pas eu de problème pour recevoir les signaux, ce qui n'a pas été notre cas. Nous avons effectué les premiers test dans la salle E306, nous n'avons pour l'instant eu aucun signal.

Mercredi :

Prise en main de l'outil de développement Android Studio avec "formation" open classroom.

Analyse de la trame du récepteur BN 641138

Face aux multiples échec de réception en salle E306 nous avons testé l'antenne en salle C201. Pour cela nous avons utilisé un oscilloscope . Nous avons effectués les test sur la pin inverseuse et la pin non inverseuse du module DCF77. Nous avons pu enfin obtenir un signal quelques instants.

La réception du signal est très sensible, une variation de l'orientation de l'antenne de quelque degrés empêche une bonne réception. Nous pensons que les alimentations à découpage des ordinateurs polluent le spectre électromagnétique local et qu'elle peuvent donc générer des signaux parasites sur la bande de 77.5 kHz. Une autre hypothèse plus probable est que la composition du bâtiment de Polytech atténue le signal déjà très faible, envoyé depuis Mainflingen.

Lorsque nous avons pu capter le signal nous l'avons récupéré sur une durée dépassant les 120 secondes. Nous avons pu ainsi décoder une trame de 60 secondes et pu récupérer l'heure. Pour récupérer cette trame nous avons simplement noté la valeur affichée à l'oscilloscope. La trame suivante est extraite de notre échantillons, après correction sur 4-5 bits nous avons pu décoder l'horaire diffusé par le système DCF77.

"trame enregistré en salle c201"

"Exemple de signal retourné par le module DCF77 sur la prise noninverseuse."

Doc, réception DCF77 : https://www.compuphase.com/mp3/h0420_timecode.htm https://blog.blinkenlight.net/experiments/dcf77/dcf77-receiver-modules/

Semaine 5

Support de transmission S.Baranowski

Étude visant à améliorer la réception du signal DCF77:

- Dans le but de placer (éventuellement redimensionner) l'antenne au mieux dans l'horloge, nous nous sommes aidé de l'analyseur de spectre présent en c203.

- Après avoir demandé conseil auprès de Mme Baranowski notre professeur de "Support de Transmission" nous avons appri que la réception pouvait être améliorée en augmentant la tension du signal reçu par l'antenne. En effet le circuit électronique post-antenne ne détecte pas nécessairement la composante de 77,5 khz qui a trop peu d'amplitude. Pour augmenter la tension du signal on s'appuie sur la formule de réception d'une antenne boucle.

Les 3 paramètres qui nous permettent d'avoir une meilleure réception sont : la surface délimité par une spire et le nombre de spires , c'est ce dernier paramètre qui est le plus facilement modifiable et que nous allons explorer.

---

Prise en main de l'environnement de développement Android Studio :

- Suivi d'une formation open classroom (https://openclassrooms.com/courses/creez-des-applications-pour-android)pour découvrir les différentes bibliothèque , les outils graphique , le language XML.

- Développement du classique jeux du nombre aléatoire pour ce familiarisé avec IDE et les bibliothèques , outils graphique.

Page d'accueil qui sera de la forme pour notre jeux final.

Page comprenant un jeux.Le jeux final sera basé sur un concept différent l'affichage ce fera sur le panneau de LED de l'horloge.

Semaine 6

Design de l'application

Nous avons commencé à développer l'application Android, nous avons choisit de découper l’application en 5 parties :

Jeux , Bluetooth , Capteur , Polytech Lille, Support , à propos. 

Dans la partie Jeux, nous aurons la commande du jeux qui sera afficher sur l'horloge.

Dans la partie Bluetooth, nous aurons les démarches pour se connecter à l'entête ainsi que la listes des appareils bluetooth.

Dans la partie Capteur , nous aurons les informations des capteurs précédents dans la raspberry.

Dans la partie Polytech Lille , nous aurons un accès différents média de Polytech Lille.

Dans la partie Support , nous aurons les informations pour envoyer un mail , au développer.

Dans la partie à Propos , nous aurons une page informative sur la projet.

Pour faciliter la navigation Nous avons développer une barre latéral de navigation qui permet d'avoir accès à n'importe quelle depuis n'importe quelle page.

"onglet de navigation"

Pour mettre en place ce type de barre de navigation,il faut créer un "objet" NavigationView dans le fichier Xml de l'activity concerné.

"onglet de navigation"

En suite il faut créer deux fichier XML Nav_header_activity qui comprendra les données graphiques de l'entête de la barre de navigation(si on se réfère à la photo ci-dessus c'est la partie verte comprenant une adresse mail et un logo), le deuxième fichier Xml à créer sera le fichier activity_activity_drawer qui lui comprend les informations graphiques pour la partie plus basse du menu (Jeux, bluetooth , etc ).

"Entête de navigation"

"Contenu du menu de navigation"

Préparation Bluetooth 

La communication bluetooth est basée sur un protocole maître-esclave (ou serveur-client). Dans notre cas l'horloge est maître et l'esclave sera le smartphone.

Nous utiliserons une communication par sockets Bluetooth (vue en cours de PSR). La norme Bluetooth propose de transférer des données en mode connecté grâce à la couche RFCOMM. Le système en couche de Bluetooth fonctionne de la même manière que pour TCP/IP, c'est pourquoi il est possible de l'utiliser via les sockets. La connexion se fait de la sorte : Si le smartphone n'a jamais été connecté à l'horloge, alors il y a appairage avec l'horloge. Cette opération n'est pas une connexion à proprement parlé mais une façon pour l'horloge de connaître l’existence du smartphone. Ensuite le smartphone se connecte avec l'horloge. L'utilisateur communique via une application faisant office d'interface user-friendly avec l'horloge.

Paramétrage bluetooth

Le côté horloge de la communication est réalisé en C a l'aide des librairies sys/socket.h et celles offerte par le noyau BlueZ, l'implantation Linux officielle de Bluetooth.

Récepteur DCF77

Nous n'avons toujours pas réussi à obtenir à nouveau une trame depuis les essais sur oscilloscope en semaine 4. Des test vont être réalisé sur Arduino pour vérifier que le problème ne vient pas des modules DCF77 ou de la Raspberry Pi sur laquelle les tentatives sont habituellement effectuées. Nous allons aussi essayer d'améliorer la réception en augmentant la taille de l'antenne en ferrite. La raison de la présence d'une ferrite au milieu de l'antenne spiral reste pour nous plutôt inconnu mais nous avons pu voir qu'il existait un bâtonnet de ferrite en vente sur internet permettant d'améliorer la synchronisation des montres utilisant le DCF77 juste en le plaçant à proximité de la montre.

Pour chercher l'origine du problème nous nous sommes rendu dans une salle de transmission de signal de Lille 1 du bâtiment P5. Avec l'aide de M.Wichmann nous avons pu tester l'efficacité de l'antenne en ferrite pour la réception du signal. Dans la salle nous obtenions une puissance de -83dbm à 77.5 kHz. Nous avons testé si l'antenne était défectueuse. En utilisant 2 antennes, une en émission, une réception, on a pu mesurer un signal sur donc l'antenne n'est pas défectueuse.

Semaine 7

Communication Bluetooth Horloge

1. Paramétrage

Après beaucoup de documentation sur internet, nous avons été en mesure d'établir une connexion bluetooth, avec un appareil Android et permettre un transfert de trame dans le sens Smartphone -> Horloge. Le message a été émis à l'aide de l'application "Bluetooth Terminal". Cette application permet d'envoyer des trames de données brut sur la couche RFCOMM.

1. Pour établir cette connexion il a d'abord fallu paramétrer la Raspberry Pi pour que son équipement Bluetooth soit activé dès l'allumage. Ceci se fait en ajoutant le service Bluetooth dans la liste des services à lancer au démarrage via la commande :

  systemctl enable bluetooth.service

2. Ensuite il faut que l'horloge soit visible par les autres appareils, dans notre cas les smartphones. Quelque soit l'appareil il faut donc qu'elle soit "discoverable". On en profite pour changer l'alias par défaut du terminal bluetooth, pour un nom plus proche de ce que l'on veut faire. Les modifications sont effectuées dans le fichier /var/lib/bluetooth/<adresse du contrôleur Bluetooth>/settings

  [General]
  Discoverable=true
  DiscoverableTimeout=0
  Alias=Horloge DCF77

L'option DiscoverableTimout permet de définir une échéance sur la visibilité de l'horloge par les autres appareils, définie à 0 il n'y a aucune échéance.

3. Il faut ensuite indiquer à l'appareil distant, quels services (protocole de communication) bluetooth offre l'appareil auquel il se connecte. Pour cela on cré un service "SP" pour "serial profile" (la couche RFCOMM étant utilisable pour une communication série) via la commande "sdptool" au lancement du service Bluetooth. Ceci l'ajoute ainsi au "Service Discovery Protocole", interrogé par un appareil distant. Dans le fichier /etc/systemd/system/dbus-org.bluez.service il faut donc modifier la ligne :

   ExecStart=/usr/lib/bluetooth/bluetoothd -C

Et ajouter la ligne :

   ExecStartPost=/usr/bin/sdptool add SP

La connexion est réalisée avec le smartphone, uniquement si ils sont appairés. Habituellement l'appairage requiert l'échange d'un code PIN entre les 2 appareils. Une personne constate l'appairage des deux appareils en vérifiant que le code PIN affiché par les terminaux est le même. Nous ne voulons pas utiliser ce code PIN puisque tout le monde doit pouvoir se connecter à l'horloge facilement et puis car l'horloge ne possède "normalement" aucune sortie graphique (exceptée les panneaux de LEDs) pour vérifier le code PIN. Heureusement BlueZ désactive le code PIN, par défaut.

2. Mise en place du serveur socket

Il y a très peu de documentation sur internet pour utiliser la librairie libbluetooth. Le peu d'information sur certaines fonctions qu'elle offre provient du site internet https://people.csail.mit.edu/albert/bluez-intro/c404.html . Un tutoriel permet d'expliquer comment utiliser les sockets pour communiquer avec la couche RFCOMM. Pour notre projet, l'horloge se comporte comme un "serveur bluetooth". Ce serveur possède une file d'attente de taille 1 puisque seul un utilisateur à la fois peut interagir avec l'horloge. La source (commentée) /horloge/Bluetooth/server/rfcomm.c est visible sur le dépôt Git https://archives.plil.fr/aknockae/projetS8_HorlogeDCF77

"Smartphone "Moto G Play" connecté à l'horloge"

"Comportement de l'horloge suite à la connexion et à la tentative d'envoi de message par le smartphone "Moto G Play""

Semaine 8

Test des perturbations sur le lieu d'installation de l'antenne

Les alimentations à découpage émettent du bruit dans une bande passante contenant la fréquence de notre antenne, nous avons analysé l'impact de celles-là sur notre antenne actuelle. Nous avons monté un oscilloscope en E306 pour pouvoir observer ces perturbations. Nous avons relié l'entrée de l'oscilloscope à l'antenne du module DCF et placée à proximité d'une installation informatique. Sans surprise la FFT indiquait un fort rayonnement des alimentations sur la fréquence de 77.5 kHz. Nous avons pu relevé une puissance allant jusqu'à 40 db de différences lorsque l'antenne est collée à l'alimentation. Toutefois il semble que cette perturbation s'affaiblisse énormément à mesure que l'on s'éloigne. A environ 2m d'une alimentation il reste encore un bruit, mais nous ne savons pas encore à l'heure actuelle, s'il est responsable de nos échecs de réceptions en E306.

Texte défilant personnel et information

Cette semaine nous nous sommes attelés au panneau de LEDs. Lundi nous avons étudié le fonctionnement de la librairie rpi-rgb-led-matrix/ déjà utilisé par les précédents créateur de l'horloge et qui permet une personnalisation complète de l'affichage. Le programme qui gère l'affichage de l'heure sur les LEDs est déjà présent dans le dossier /var/www/html et est lancé au démarrage. Ce programme provient d'un exemple déjà présent sur le dépôt git de la bibliothèque. La bibliothèque est écrite en C++ pour permettre de considérer un (ou plusieurs panneau de LED) comme un objet. Les classes fournie sont :

• Canvas : représente une surface de taille 16x32 ou 32x32 pixel. Canvas possède plusieurs méthodes permettant de modifier la couleur d'un seul pixel, ou de la surface entière
• RGBMatrix : hérite de Canvas, transpose la surface fictive de Canvas et le gère sur le panneau de LEDs
• Font : permet de charger une police au format bdf et d'afficher un texte sur le Canvas facilement.

Un des objectif avec le panneau de LED et de faire défiler soit un message personnel, soit une suite de titre issue d'un flux RSS/ATOM quelconque. Les flux RSS (ou ATOM) sont des fichiers XML ayant une syntaxe normée, présent sur beaucoup de site internet. Souvent présent sur les sites d'actualité en tout genre ils permettent d'accéder facilement aux dernière nouvelles, tel des billets de blog ou des articles. Notre horloge pourra ainsi afficher soit les titres de l'actualité d'un site d'information ou alors les titres d'un nouveau billet de blog d'un site que l'utilisateur fréquente. Il pourra personnaliser cet affichage en renseignant l'adresse URL du site internet en question dans un champ de texte dans le menu information de l'application Android.

Mercredi et Jeudi nous nous sommes attelés à la programmation du texte défilant. Le programme affichant un message défilant sur le panneau de LED s'appelle bandeau.cpp et se trouve dans le dossier /horloge/ledPanel du projet. Au sein de ce dossier ledPanel se trouve la librairie statique de librgbmatrix.a ainsi que les "includes" nécessaires à la librairie. Le programme bandeau.cpp se charge d'afficher les titres qui seront stockés dans un fichier, et récupèrera directement le message depuis le serveur Bluetooth. Nous avons codé la fonction strHorizontalScroll prenant en paramètres le canvas, la police, la couleur, la chaîne de caractères et le délai de maintient du message sur les même pixels (la vitesse de déplacement). Pour l'instant cette fonction affiche directement un texte défilant sur les 2 matrices de LEDs. Cependant nous souhaitons afficher le texte sur les LEDs du haut et l'heure sur les LEDs du bas.

En fin de semaine nous avons aussi codé le programme qui extrait les premiers titres d'un flux RSS ou ATOM. Pour l'instant nous avons réussi à extraire les titres, il reste à les enregistrer dans un fichier texte pour qu'ils puissent être lu par le programme bandeau.cpp. Pour l'extraction, étant donné que les fichiers RSS/ATOM sont écrits en XML, nous avons utilisé la librairie tinyXML2, écrite en C++. Cette librairie a l'avantage d'être légère et possède les fonctionnalités minimales d'un analyseur de syntaxe XML. Comme nos actions sur le fichier de flux se résument surtout à accéder aux différents nœuds, nom donné à tout élément dans un fichier xml, alors elle est adéquate. De plus comme pour librgbmatrix, libtinyxml fonctionne sous forme de classe, ainsi on peut aisément représenter chaque nœuds par un objet XMLNode ou XMLElement.

Typiquement les fichiers RSS ont pour syntaxe (source wikipedia) :

<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0">
<channel>
  <title>W3Schools Home Page</title>
  <link>https://www.w3schools.com</link>
  <description>Free web building tutorials</description>
  <item>
    <title>RSS Tutorial</title>
    <link>https://www.w3schools.com/xml/xml_rss.asp</link>
    <description>New RSS tutorial on W3Schools</description>
  </item>...

Et les fichiers ATOM (source wikipédia) :

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">

 <title>Fil d'exemple</title>
 <subtitle>Un titre secondaire.</subtitle>
 <link href="http://example.org/"/>
 <updated>2010-05-13T18:30:02Z</updated>
 <author>
   <name>Paul Martin</name>
   <email>paulmartin@example.com</email>
 </author>
 <id>urn:uuid:60a76c80-d399-11d9-b91C-0003939e0af6</id>

 <entry>
   <title>Des robots propulsés par Atom deviennent fous</title>
   <link href="http://example.org/2003/12/13/atom03"/>
   <updated>2010-04-01T18:30:02Z</updated>
   <summary>Poisson d'avril !</summary>
 </entry>

</feed>

Notre programme récupère le contenu des balises <title> présentes dans les balises <item> pour les flux RSS et <entry> pour les flux ATOM. Chacune des item et entry étant un billet ou un article différent.

Le débogage du programme a pris du temps puisqu'une fuite mémoire est apparue une fois le programme finie. Les seuls allocations réalisées sont celles qui permettent de créer la liste des chaînes de caractères contenant les titres. L'usage de Valgrind nous a bien aidé et a permis de voir que la liste était correctement désallouée. De fil en aiguille nous avons conclu que la fuite de mémoire venait de la déclaration de l'objet XMLDocument, représentant le document XML dans le programme et permettant de le charger. Nous ne négligeons pas cette fuite de mémoire. Nous continuerons de trouver une alternative pour l'éviter plus tard.

Modification du serveur Bluetooth

En fin de semaine toujours, nous avons tenté de mettre en place une file de messages Unix. La file de message permet de faire communiquer le programme serveur avec les autres programmes bandeau et jeu notamment. Le programme server gravite autour de la file de messages. Il effectue le transfert des commandes reçues depuis Bluetooth vers les programmes et inversement; programmes animant les diverses fonctionnalités de notre horloge. Beaucoup de temps à été passé sur la file de message. Une mauvaise configuration nous a longtemps empêché de recevoir les messages émis.

Nous avons aussi décomposé le code du serveur en fonctions pour une meilleur clarté du "main".

Application

• Partie Jeux :

La partie Jeux de notre application est la partie principale de notre application , d'un point de vue graphique et fonctionnalité elle est assez simple. Elle se compose de trois éléments : un décors , une zone de texte au milieu permettant d'informer l'utilisateur de l'état du jeux ( pas démarrer , démarrer ,score temps réel , perdu ) et d'un bouton de commande ( la flèche).

"Page de l'activité Jeux ( en mode développement)"

Le jeux fonctionne de la manière suivante : l'utilisateur sera connecté à l'horloge , il appuiera pour sur le bouton JUMP pour démarrer et sur l'horloge démarra une animation ( sur la matrice de LED du haut) comme celle de la page de chargement de Google chrome, c'est à dire un "dinosaure" qui devras sauter au dessus de différent obstacle , le "dinosaure " reste mobile ce sont les obstacles qui se déplace.

D'un point de vue " logiciel" l'activité jeux se connecte en Bluetooth à l'horloge, nous avons mis en place des sécurités permettant premièrement que le Bluetooth est activé , deuxièmement qu'un appareil de type horloge soit associé à notre téléphone.

"sécurité bluetooth activé"

Si le Bluetooth n'est pas activé on renvoie l'utilisateur vers l'activité Bluetooth qui gère les connexions.L'activité Bluetooth vas demander à l'utilisateur d'activer le Bluetooth de son téléphone.

L'autre vérifications mise en place est l'association du téléphone avec une horloge ( nous ne fermons pas l'application à une seule horloge au cas ou dans le future plusieurs horloges seraient installées). Nous parcourons la liste des appareils Bluetooth associés avec le téléphone et vérifions si ce sont des

équipement nommé Horloge , nous avons pas fait de  vérification par adresse mac car nous sommes pas capables de connaitre les futures adresses mac d'éventuelles future horloge. Dans l'éventualité ou une autre équipement Bluetooth comporterait le même nom ,la partie traitement de la socket en provenance de l'horloge s'occupera de gérer ce cas. 

Avec la méthode getBondedDevices() nous avons pu récupérer la liste des équipements associés à ce téléphone ,nous effectuons une recherche( via la méthode de la classe String Indexof) parmi la liste d'équipement d'un équipement nommé Horloge qui sera connecté au téléphone (via un thread que je détails après). Si l'appareil n'a pas d'équipement horloge ou d'équipement quelconque associé , on renvoie l'utilisateur vers l'activité Bluetooth qui vas gérer l'association avec une horloge.

• Partie Bluetooth :

La partie Bluetooth de notre application sert à gérer la connexion entre l'horloge et le téléphone. Elle est appelé depuis la bar de naviagtion mais aussi depuis les autres pages lorsque la communication bluetooth n'est pas fonctionnel.

"Page de l'activité Bluetooth à l'ouverture"

"Page de l'activité Bluetooth( en mode développement)"

La Page comprend un objet de type spinners qui est une liste déroulantes qui référence tout les objets horloge bluetooth déjà associé présente elle sert de sélection d'horloge, une deuxième liste déroulante comprenant les horloge accessible mais non associé est en développement. Comme on peut le voir sur la photo de droite lorsque que le bluetooth n'est pas activé , il est demandé à l'utilisateur de le faire.

Si le Bluetooth n'est pas activé on démarre une activité par dessus la page qui s'affiche tant que l'on pas sélectionné une option.

Pour la partie listing des équipement nommé Bluetooth , nous ferons au même fonction qu'évoqué dans la partie Jeux. Le listing des équipements non associé nous utiliserons un broadcast receiver ( cette partie est en cours de développement).

• Partie connexion :

Pour cette partie nous sommes beaucoup aidé de la documentation en ligne android  : https://developer.android.com/guide/topics/connectivity/bluetooth.html Pour avoir une connexion avec un appareil , il faut créer un thread qui gère la connexion quelle que soit la tâche réalisé par l'application. On passe en paramètre du constructeur du thread un objet BluetoothDevice qui référença l'horloge à connecter. Il y a une méthode run pour démarrer et une méthode cancel à appeler lors de la déconnexion. Nous avons

nous avons mis des méthodes lecture et écriture qui permette lecture et écriture de la socket.

Semaine 9

Cette semaine nous avons enfin réussi à capter un signal correct provenant de l'antenne de Mainflingen. Suite à cela nous nous sommes attaqués à la programmation du programme décodeur.

Réception du signal

Nouveaux tests réalisé

(code source)

Après les nombreux essais infructueux de réception DCF77, nous avons enfin pu obtenir un résultat plutôt convaincant. Le gros problème en travaillant sur une fréquence de 77.5 kHz, est qu'elle se situe sur la large bande passante des ondes émises par les alimentations à découpage des appareils électriques. Ces ondes sont donc très présentes en salle de projet. Après en avoir discuté avec les tuteurs de projet, nous avons décidé de tester le programme de réception en extérieur, pas seulement l’efficacité de l'antenne. Jusqu'à présent la réception a été testée en intérieur. Nous avons donc mis en place un programme python, simple, permettant d'accéder rapidement aux valeurs retournées par l'antenne :

(INSERER SOURCE PYTHON)

Finalement il n'a pas été testé en extérieur, seulement en collant l'antenne à une fenêtre au fond de la salle E304. Avec surprise, parce que nous étions quand même à moins de 2 mètres des ordinateurs, nous avons reçu périodiquement une suite de bits correspondant à ce qu'envoie l'antenne de Mainflingen.

(INSERER ECHANTILLONS RECUPERE)

Une trame DCF77 envoie un bit toutes les secondes. Quand il n'y a pas de bit le module, si on effectue les relevés sur la sortie non inverseuse du DCF77, retourne 0 Volts. Un bit de valeur 0 correspond à la sortie à l'état haut, pour nous 3.3V, pendant 100 ms. Un bit de valeur 1 correspond à la sortie à l'état haut sur une durée de 200 ms. Nous lisons donc l'état de la pin GPIO de la Raspberry Pi toutes les 100 ms. Les relevés sont enregistré dans un tableau. Si 2 case adjacentes ont pour valeur 1 alors le bit correspondant vaut 1. Si une case est à 1 et la suivante à 0, alors cela correspond à un état 0 envoyé par l'antenne. En effectuant les mesures toutes les 100 ms, on a pour garantie qu'aucun bit n'est pas oublié lors de la mesure. Nous aurions pu effectuer la mesure aussi sur 50ms, sauf qu'un bit à l'état haut aurait été symbolisé par 4 cases valant 1, et 2 cases valant 1 pour un état bas. Le schéma (qui n'est pas à l'échelle pour l'intervalle entre 2 bits) montre l'instant de prélèvement des bits (les barres verticales):

Accès aux GPIOs en C

Après avoir trouvé cette méthode de prélèvement, nous sommes passés à la création du programme de décryptage de l'heure. Pour cela il fallait accéder du point de vue logiciel, aux GPIOs. Nous ne savions pas du tout comment faire en C. Beaucoup d'exemple sur internet proposait via Python, mais il n'était pas question pour nous de programmer dans ce langage. Ça syntaxe est certes facile, mais de l'autre côté le langage est interprété donc son exécution est plus lourde et pas forcément plus rapide que pour un programme écrit en C. Nous avions aussi découvert, au début du projet, l’existence de la bibliothèque wiringPI, permettant d'accéder aux GPIO de la même manière qu'aux pin d'une arduino. Cependant cette bibliothèque possède un niveau d’abstraction trop haut pour notre utilisation des GPIOs. En fin de compte nous devions juste lire sur une pin. Après beaucoup de recherche nous avons finalement trouvé que les GPIOs pouvaient être accessible facilement, même depuis le shell [1].

Le système de gestion des pins se trouve à l'adresse /sys/class/gpio et existe sur la plupart des distributions linux, même sur les systèmes n'en possédant pas. Ce dossier contient ce qui semble être des fichiers accessibles uniquement en écriture par l'utilisateur root : export et unexport. Par défaut les GPIOs ne sont activés, pour les activer il suffit d'écrire le numéro du GPIO dans le fichier export. Par la suite un dossier gpio*numero* est créé contenant les fichiers :

• active_low : permettant d'indiquer la valeur binaire correspondant à un état bas.
• value : en lecture, permet de lire l'état de la pin GPIO
• direction : configure la pin en entrée ou en sortie
• edge : spécifie si la valeur haute correspond à un front montant, un état haut complet ou un front descendant

Lorsqu'on ne souhaite plus utiliser la GPIO, il suffit d'écrire son numéro dans le fichier unexport. En partant de cela, il est facile d'accéder aux GPIOs en C à l'aide des fonctions de gestion des descripteurs de fichiers. Nous avons trouvé un exemple de code sur le site eLinux et l'avons repris pour l'adapter à notre utilisation en ajoutant la fonction paramétrant la valeur de retour sur un état bas. (Fichier GPIOaccess.c sur le dépôt Git). Les autres fonctions permettent d'activer un GPIO, de lire son état et d'établir sa direction. Les fonctions sont disponibles sous forme d'une bibliothèque statique nommée libGPIOaccess.

Suite à la programmation de ces fonctions de gestions des ports GPIO, nous avons codé le programme de décryptage de l'heure. Ce programme est désormais fonctionnel.

Décryptage de l'heure

Le programme de décryptage fonctionne en 3 temps :

• Écoute du port GPIO pendant au moins 2 trames (fonctionnel)
• Extraction d'une trame correct de l’échantillon de l'écoute (fonctionnel)
• Modification de l'horloge interne du système Linux (à faire)

Dans un premiers temps on récupère toutes les 100 ms la valeur de la pin 17 du GPIO reliée à la sortie non inverseuse du module BN641138 et cela pendant une durée de 1300 ms ce qui correspond à une écoute sur 130 secondes. Sachant qu'une trame complète dure 60 secondes nous sommes sûr d'en obtenir au moins une complète.

(A FINIR)

Semaine 10

Nous avons commencé cette semaine à étudiez la gestion des arrêts brusque.Lorsque que quelqu'un débranche sans précaution l'horloge , il faut que la Raspberry s'éteigne correctement pour elle est alimentée par une batterie et uniquement la raspberry pas le panneau de LED qui consomme 2A et qui nécessiterait une batterie pour les arrêts beaucoup plus grosse.

Pour gérer les arrêts brusque , il nous faut switcher entre l'alimentation et la batterie dès que l'alimentation principale n'est pas relié au secteur. Lorsque que l'alimentation n'est pas relié au secteur on doit aussi envoyer l'information à la raspberry pour commence l'éteindre.

La première solution choisit pour résoudre c'est deux fonction est la suivante :

" Schéma papier du descriptif "

Ce schéma représente partie où gère le changement entre alimentation partie adaptateur secteur et alimentation par batterie. Il y 2 grosse partie une partie avec un comparateur qui vas comparer la tension adaptateur secteur et batterie et renvoyer au Gpio un niveau logique 1 pour l'informé que l'adaptateur secteur est éteint.

La batterie est relié à une diode puis à la Raspberry lorsque le tension de adaptateur secteur diminue suite à la coupure la diode conduit et la batterie alimente la raspberry.

Nous avons aussi mis une diode évitant que la batterie "alimente" l'adaptateur secteur et contrôleur de batterie.

Le contrôleur , nous utilisons un LT1512 on se utilise la Typical Application fournit avec la datasheet car elle correspond à notre besoin.

Typical_application.PNG

[Fichier:Typical_application.PNG|500px|thumb|center|" typical application "]]