Version du 13 mai 2018 à 20:46

Sommaire

1 Présentation générale
- 1.1 Description
- 1.2 Objectifs
2 Analyse du projet
3 Préparation du projet
4 Réalisation du Projet
5 Documents Rendus

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

Calendrier prévisionnel

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 S2	Heures S3	Heures S7	Heures S8	Heures S9	Heures S10
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 :

import time
from RPi import GPIO
b1=17
print b1
GPIO.setmode(GPIO.BCM)
GPIO.setup(b1, GPIO.IN, pull_up_down=GPIO.PUD_UP)
fichier = open("fichier22.txt","a");
i=0
while i<=600:
        inputVal = GPIO.input(b1)
        fichier.write(str(inputVal))
        print inputVal
        time.sleep(0.1)
        i=i+1
fichier.close()

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.

100000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000001101111100000000000000000000000000000000
000000000000000000000000000000000000100000000011000000001000000000100000000010000
000000100000000011000000001100000000110000000010000000001100000000110000000010000
000000100000000010000000001000000000100000000010000000001100000000110000000010000
000000100000000010000000001000000000000000000010000000001000000000110000000010000
000000100000001011000000001000000000100000000010000000001000000000110000000011000
00000011000000001100010000110000000010000

On remarque que lors de cette mesure, le module n'a étonnement pas renvoyé beaucoup de signaux parasites. Contrairement à toutes nos mesure effectué jusque là.

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.

Par la suite une fonction decodeSample va se charger d'extraire une trame de l'échantillon. Pour cela, il y a existe certains bits particuliers :

Le bit 0 est toujours à 0
Le bit 20 est toujours à 1
Il n'y aucun bit sur la 59e seconde hormis lors de l'ajout d'une seconde intercalaire, phénomène rare donc non pris en compte pour l'instant par notre programme

Les premiers test ne donnait jamais la bonne heure, même si les échantillons était très peu affectés par les bits parasites. Il a donc fallu renforcer la vérification en y incluant les bits de parité paire et en recalculant cette parité :

Le bit 28, pour la parité des minutes
Le bit 35, pour la parité des heures
Le bit 58, pour la parité de la date

Ainsi si la parité n'est pas correct on cherche une nouvelle trame. Une fois la trame correct récupérée, on calcul les heures et les minutes et on les enregistrant dans une structure.

Résultats

Les test de ce programme ont été effectués dans un endroit dépourvue d'appareils électriques dans un rayon d'au moins 5 mètres, hormis d'un ordinateur et son alimentation. Plusieurs tests ont été effectués et il semble que si l'antenne est surélevée par rapport au bloc d'alimentation, le programme récupère l'heure plus facilement.

Notre plus grosse erreur au cours de ce projet a été de penser qu'il était impossible d'obtenir l'heure depuis un signal pollué par des bits parasites.

Or il est tout à fait possible de le faire, ce que démontre notre méthode de détection de trames. On remarque aussi que plus le signal est pollué, plus il faut mettre en œuvre des méthodes de vérifications d'intégrité. Ce qui est de plus en plus difficile puisque, hormis les bits fixe quelque soit la trame ou les bits de parité, il n'est pas possible de vérifier directement la conformité de la trame.

Semaine 10

PCB de la batterie de secours

Nous avons commencé cette semaine à étudier la gestion des arrêts brusques de l'horloge. Lorsque quelqu'un débranche sans précaution l'horloge, il faut que la Raspberry et son système Linux s'éteigne correctement. Pour cela, elle est alimentée par une batterie. Cette batterie permet d'alimenter la Raspberry, au minimum, pendant la durée de son extinction propre. A l'instant où la batterie prend le relai sur l'alimentation, les LEDs s'éteignent. Les 2 panneaux de LEDs peuvent consommer jusqu'à 2 Ampères, il nous faudrait alors une batterie beaucoup plus robuste et inutilement grosse pour supporter un courant aussi fort.

Pour gérer les arrêts brusque, il nous faut basculer sur la batterie dès que l'alimentation principale n'est plus reliée au secteur. Lorsque l'alimentation n'est pas reliée au secteur il faut aussi envoyer l'information à la raspberry, via un GPIO, sur laquelle tourne un programme qui exécute la commande halt, éteignant le système proprement.

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

" Schéma papier du descriptif "

Ce schéma représente partie qui gère le changement entre l'alimentation secteur et alimentation par batterie. Il y 2 grosse partie une partie avec un comparateur qui comparera la tension adaptateur secteur et la tension de la batterie tout en envoyant vers une pin GPIO un niveau logique 1 pour indiquer à la raspberry que l'alimentation électrique murale est absente.

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

Une diode supplémentaire, située à proximité de la batterie permet d’empêcher que la batterie alimente l'adaptateur secteur.

Le contrôleur que nous utilisons est un LT1512, le montage de chargement de batterie correspond à l'application typique réalisée avec ce boîtier.

" typical application "

Retour sur la détection de l'heure

Suite à la réussite de la détection de l'heure dans un environnement à proximité de l'air libre. Nous avons effectués d'autres tests dans un environnement confiné, comme un appartement étudiant. Le programme semble avoir beaucoup plus de mal a récupérer l'heure.

Nous sommes toujours à la recherche de moyens de vérification de conformité de la trame. A ce propos en faisant des récupérations de l'heure, le programme se trompe et renvoie des heures supérieurs à 24 et des minutes supérieurs à 60. Il est donc possible d'ajouter un moyen de vérification supplémentaire pour détecter les dépassements de valeurs. Nous allons aussi mettre en place cette vérification sur la date. Les jours ne dépasseront jamais 31 et les mois 12.

Pour aller plus loin, il est peut-être aussi possible de corriger les bits ayant des valeurs incorrects.

Serveur bluetooth

Suite à la découverte et de la prise en main du bluetooth sous linux. Nous avons commencé la réalisation du serveur bluetooth. Lancé en arrière plan dans un thread parallèle, il est chargé d'écouter les données venant de l'application mobile tout en étant capable d'en envoyer. Le serveur se trouve en arrière plan pour laisser les future tâche d'affichage du bandeau et du jeu s’exécuter, tout en étant à l'écoute des consignes envoyées par l’utilisateur.

Semaine 11

Finalisation PCB

Nous avons réalisé sur Altium un schematic regroupant toutes les parties de la carte :

" Schemantic version 1 "

Comme on peut le voir il " manque" une diode par rapport au schéma précédent, c'est normal nous utilisons celle présente sur le shield qui sépare l'alimentation des LEDS est celle de la Raspberry. nous avons donc un connecteur supplémentaire.

Dans la partie qui compare la tension de l'alimentation est celle de la batterie , nous avons utilisé un TL081 comme comparateur. Le reste des composant a été choisit en fonction des indications du constructeur du contrôleur de batterie.

Il faut calculer les valeurs de R1 et R2 , pour R2 la datasheet conseil de prendre 12.4k

on prend la  formule  suivant  de la datasheet :

// photo datasheet

R2 donnée dans la datasheet

R1 = 8878,5498 ohm

L1A et L1B sont données dans la datasheet pour 33µh chacun. Les inductances ont le même coeur

Icoups = 0.561 correspond au courant maximale d’ondulation pour la capacité de découplage IIN = 0.016 A, courant d’alimentation du LT1512

Liste des composants présent sur la carte:

- LT1512 - contrôleur batterie

- TL081 - AOP pour comparateur

- condensateur c1 22µf

- condensateur c2 0.22 µf

- condensateur c3 0.22 µf

- condensateur c4 0.22 µf

- condensateur c5 0.1 µf

- résistances r1 : 1kohm r2: 12,4kohm r3 : 0.2 ohm r4 : 24 ohms

- inductance ctx33

- diode schottky D1 D4 10TQ035

- diode D3 1N4001

Nous avons également réalisé une première version du PCB :

" PCB version 1 "

Finalisation PCB v.2

Après réflexion et retour sur l'étude de la carte nous avons réalisé plusieurs modification. Dans un premier temps nous avons pris en compte le rallumage de la raspberry automatiquement lorsqu'on rebranche l'horloge à la prise électrique 230v. Lorsque l'OS d'une raspberry s'éteint, celle-ci reste "en veille". Pour démarrer à nouveau l'OS il faut retirer et remettre l'alimentation. Nous avons étudié deux solutions la première : gérer l'allumage via une pin du GPIO à la manière des boutons ON/OFF. La deuxième solution, plus "automatique", consiste à arrêter d'alimenter la Raspberry une fois l'extinction correct de l'OS Linux. Nous détectons l'extinction de l'OS à l'aide d'une pin GPIO qui passe à 0V lorsque l'OS s’éteint. Cette solution est moins gourmande en composant.

Pour mettre en œuvre cette fonctionnalité nous avons simplement utilisé un transistor (NPN) "commandé" par la pin. Lorsque celle-ci est à l'état haut, le transistor laisse passer le courant qui va de la batterie, vers la raspberry (en cas de coupure, bien sûr). Lorsque la pin passe à 0, la batterie cesse d'alimenter l'ensemble de l'horloge. Il suffit alors de rebrancher la prise secteur pour rallumer la raspberry pi.

Nous avons aussi enlevé le comparateur qui n'était pas nécessaire et nous avons simplement brancher l'adaptateur sur la pin GPIO dédié(on adapte bien sûr la tension à 3.3v tension d'entrée nominale de cette pin gpio).

Voici le schéma de la solution :

voici la nouvelle liste de composants :