Compagnon Intelligent pour Alzheimer : Système d'Alerte Basé sur Arduino

Composants et fournitures

Arduino MKR1000	×	1
Infineon Sensor Hub Nano	×	1
Écran LCD Nokia 5110	×	1
Module Bluetooth HC-05	×	1
Plaque d'essai (breadboard)	×	1
Fils de connexion (génériques)	×	1
Bouton poussoir 12mm SparkFun	×	1
Buzzer	×	1
Émetteur FT1235 5W	×	1
Récepteur FT1236 5W	×	1

Outils nécessaires

• Fer à souder (générique)

Applications et services en ligne

• Arduino IDE
• Blynk
• IFTTT Maker service

À propos de ce projet

Ces faits, cités directement depuis le site de l'Association Alzheimer (septembre 2017), suffisent à donner une idée des problèmes qu'une personne traverse si elle ou ses proches sont atteints de la maladie d'Alzheimer.

En tant que maker, j'ai réfléchi à cela et décidé de construire un dispositif portable, un système qui peut aider à la fois les patients et leurs aidants.

Ce système doit être capable d'effectuer au moins les tâches suivantes :

• Rappeler au patient les tâches quotidiennes (médicaments, exercice, etc.)
• Surveiller où se trouve le patient dans la maison
• Alerter les aidants en cas d'urgence
• Afficher l'heure (c'est une montre, après tout !)
• Être portable et facile à utiliser, même pour un patient âgé
• Maintenir le coût au minimum

Quand j'ai vu le Sensor Hub Nano d'Infineon, il m'est apparu comme un bon candidat pour ce projet, grâce à sa taille très réduite et ses capacités BLE. Avec sa détection de pression précise, il pouvait être utilisé pour détecter si le patient a chuté et aussi indiquer exactement où il se trouve dans la maison.

J'utiliserai les composants suivants pour le projet de base :

• Infineon Sensor Hub Nano
• Arduino MKR1000
• Module Bluetooth HC-05
• Écran Nokia 5110

Vous comprendrez ce que je veux dire par « projet de base » en lisant la section « Personnaliser l'Assistant Alzheimer ».

Comment ça fonctionne

Dans cette section, je décrirai brièvement comment fonctionne la montre et les étapes à suivre pour la faire fonctionner.

La carte d'évaluation Sensor Hub Nano d'Infineon possède un capteur barométrique DPS310, qui envoie ses données via Bluetooth. Les valeurs de pression, altitude et température peuvent être visualisées dans l'application Android d'Infineon (télécharger ici) ainsi que dans le logiciel d'évaluation SES2G. Les utilisateurs peuvent aussi créer des applications Android avec la bibliothèque fournie par Infineon, selon leurs besoins.

Plus d'infos sur le Sensor Hub Nano ici.

Mais je veux que l'Assistant Alzheimer fonctionne sans téléphone Android entre les deux. Il doit être un dispositif portable autonome, tout en pouvant se connecter à un smartphone pour visualiser les données des capteurs. J'ai donc décidé d'utiliser un Arduino MKR1000 pour son format compact et sa capacité WiFi, et de le connecter d'une manière ou d'une autre au Sensor Hub Nano.

Voici le pinout de l'Arduino MKR1000 qui vous sera utile :

J'avais un module Bluetooth HC-05, et j'ai dû l'utiliser pour la connexion entre l'Arduino MKR1000 et le Sensor Hub Nano. Mais d'abord, nous devons connecter correctement le HC-05 aux broches Tx et Rx matérielles de l'Arduino, en tenant compte des niveaux logiques. Mon module Bluetooth fonctionne en 3.3V, comme le MKR1000, donc pas besoin de convertisseur de niveau. Mais si votre module fonctionne en 5V, vous aurez peut-être besoin d'un convertisseur de niveau comme celui montré.

Après avoir adapté les niveaux de tension, nous devons appairer le HC-05 avec le Sensor Hub Nano pour commencer la communication de données entre eux, et trouver un moyen simple pour qu'ils s'apparient automatiquement à chaque fois que le Sensor Hub Nano entre dans la portée Bluetooth du HC-05.

Pour cela, j'ai pensé à configurer le HC-05 pour agir comme un dispositif Bluetooth « maître », et l'apparier uniquement avec une adresse MAC spécifique : celle du Sensor Hub Nano. Ainsi, une fois configuré ainsi, dès que vous allumez le HC-05, il recherche un dispositif avec une adresse MAC spécifique (celle du Sensor Hub Nano) et s'apparie automatiquement, laissant à l'utilisateur l'envoi et la réception de données.

Cela se fait avec des commandes AT pour le HC-05, couvert dans la section « Configuration du Module Bluetooth ».

Note : J'ai joint un document trouvé en ligne, listant toutes les commandes AT supportées par le HC-05, utilisez-les selon vos besoins.

Une fois appairé et connecté correctement, l'envoi de commandes au Sensor Hub Nano ressemble à un terminal Bluetooth. Vous pouvez utiliser les commandes spécifiées ci-dessus en les imprimant simplement comme une String, via le port série matériel auquel le HC-05 est connecté. Par exemple, voici la commande pour démarrer le flux de données du capteur :

$start_sensor id=1 // Pour démarrer le flux de données du capteur

Voici la liste des commandes que je connais :

$hello id= // Hello
$info id= // Info
$sinfo id=1 // Info capteur
$set_mode sid=1;md=mode;val=bg // Faible énergie
$set_mode sid=1;md=prs_osr;val=16 // Mode standard
$set_mode sid=1;md=prs_mr;val=32 // Haute précision
$start_sensor id=1 // Démarrer
$stop id= // Arrêter

Les données du capteur provenant du Sensor Hub Nano sont dans ce format :

$1,t,36.9299,1154206 // Température
$1,p,997.6813,1154206 // Pression
$1,a,130.4305,1154206 // Altitude

Note : Je tiens à faire référence à l'article de blog de Peter Smith, qui m'a aidé à démarrer la communication avec le Sensor Hub Nano via Bluetooth.

Une fois capable de démarrer le flux de données du module, nous avons besoin d'un moyen de parser les données. C'était, je l'avoue, la partie la plus difficile du projet ; une fois la commande de démarrage envoyée, le Sensor Hub Nano envoie juste un flux de données, laissant au dispositif récepteur le soin de parser quelque chose de sensé. Après avoir essayé de nombreuses méthodes de complexité variable (que je ne détaillerai pas ici), voici la méthode la plus simple et efficace que j'ai trouvée pour parser les données du Sensor Hub Nano.

void getSensorValues() {
  // Récupère les valeurs du capteur depuis le Sensor Hub Nano via le port Serial1
  String junkVal;
  if (Serial1.available()) {
    junkVal = Serial1.readStringUntil('\n');
    junkVal = Serial1.readStringUntil('t');
    t = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('p');
    p = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('a');
    a = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('\n');
  }
}

Un écran sera aussi connecté à l'Arduino pour interagir avec l'utilisateur, afficher messages, heure ou données du capteur (plus de détails plus loin).

Une fois les données reçues dans l'Arduino MKR1000, grâce à sa connectivité sans fil, vous pouvez les envoyer vers différentes plateformes IoT, comme Cayenne ou Blynk.

J'avais choisi Cayenne, impressionné par son interface magnifique et sa configuration facile. Mais hélas, il y avait des bugs avec la connexion WiFi du MKR1000 qui empêchaient la sélection des broches. L'équipe de Cayenne a été très serviable, mais le problème n'a pas été résolu. J'ai donc opté pour Blynk à la fin, mais ils sont très similaires, il suffit de changer quelques lignes de code Arduino pour passer de Blynk à Cayenne si vous voulez tester ou une fois le problème résolu. Les deux ont à peu près les mêmes fonctionnalités, c'est juste une question de préférence. L'avantage de Cayenne est qu'on peut y accéder sur PC, alors que Blynk ne fonctionne que sur smartphones.

Maintenant, nous avons reçu les données du Sensor Hub Nano, les avons mises dans l'Arduino, et les avons transférées vers une plateforme IoT (je dirai Blynk désormais). Maintenant, il ne reste plus qu'à personnaliser l'Assistant Alzheimer selon vos besoins, ce qui est traité dans une autre section (détection de chute et de localisation discutées là-bas).

Note : J'ai essayé de documenter chaque étape en détail, mais si vous ne savez pas quelque chose (comme téléverser du code sur votre Arduino), il serait préférable d'aller sur la page d'accueil Arduino, de vous familiariser un moment, puis de revenir ici une fois que vous connaissez au moins les bases.

Configuration du module Bluetooth

La première chose à faire est d'obtenir l'adresse MAC de votre Kit d'Évaluation Sensor Hub Nano. Il y a plusieurs façons, je vais vous dire comment j'ai fait.

Appairez le Sensor Hub Nano avec votre smartphone :

Téléchargez l'application d'évaluation Sensor Hub Nano d'Infineon (pour Android) ici et allumez votre Sensor Hub Nano. Ouvrez l'application, elle affichera le Sensor Hub Nano comme « IFX_NANOHUB », avec l'adresse MAC en dessous.

Notez-la, vous en aurez besoin plus tard.

Note : Il vaudrait mieux désapparier le Sensor Hub Nano de votre smartphone si vous ne l'utilisez pas maintenant, car si votre téléphone est à proximité avec le Bluetooth allumé et le Sensor Hub Nano appairé, le téléphone se connecte automatiquement. Et quand vous configurerez le HC-05 pour qu'il s'appaire avec le Nano Hub, il ne se connectera tout simplement pas.

Mettre le HC-05 en mode AT :

Le mode AT permet de configurer les paramètres du module Bluetooth HC-05 ; régler le baud rate, définir s'il doit se connecter comme esclave ou maître, etc. Nous devrons changer certains paramètres pour permettre au module de récupérer les données avec succès du Sensor Hub Nano d'Infineon.

D'abord, téléversez le sketch « Commandes AT » sur l'Arduino MKR1000. Cela nous permettra de donner des commandes au module Bluetooth en mode AT, via l'Arduino MKR1000.

// Sketch original du blog de Martyn Currey :
// https://www.martyncurrey.com/arduino-with-hc-05-bluetooth-module-at-mode/
//
// Sketch modifié par moi pour fonctionner avec Arduino MKR1000 !
//
// Sketch Bluetooth de base
// Connectez le module HC-05 et communiquez via le moniteur série
//
// Le HC-05 démarre en mode communication par défaut.
// Doit être mis en mode AT
// Après reset usine, le baud rate par défaut pour le mode communication est 38400
char c = ' ';
void setup() {
  Serial.begin(9600);
  Serial.println("Arduino avec HC-05 prêt");
  Serial1.begin(38400);
  Serial.println("Serial1 démarré à 38400");
}
void loop() {
  if (Serial1.available()) {
    c = Serial1.read();
    Serial.write(c);
  }
  if (Serial.available()) {
    c = Serial.read();
    Serial.write(c);
    Serial1.write(c);
  }
}

Puis câblez uniquement le module Bluetooth à l'Arduino MKR1000 selon le schéma.

Note : Il serait judicieux de tout câbler d'abord sur une breadboard, puis de passer au câblage définitif une fois que c'est bien configuré.

Si vous essayez d'allumer le Sensor Hub Nano et le HC-05, vous verrez qu'ils ne se connectent pas automatiquement pour l'instant.

Pour changer les paramètres du HC-05, il faut le mettre en mode AT. La méthode dépend de votre carte breakout, vous devrez peut-être faire différemment. Si vous avez un module différent du mien, allez sur le blog de Martyn Currey ici pour des infos détaillées sur comment mettre les modules HC-05 en mode AT. Si vous êtes bloqué, googlez votre problème ou commentez et j'essaierai d'aider.

Mon module a un bouton switch, donc je fais ceci pour le mettre en mode commande AT (N'oubliez pas de téléverser le code AT command sur l'Arduino) :

• Débranchez l'alimentation du module (TX et RX restent connectés !)
• Appuyez et maintenez le bouton switch sur le module
• Alimentez tout en maintenant le bouton
• Quand la LED s'allume, relâchez le switch

Une vidéo montrant comment mettre le HC-05 en mode AT :

Une fois en mode AT, vous remarquerez une différence notable dans le clignotement de la LED du HC-05. En mode communication, la LED clignote vite, ~5 fois/seconde ; en mode AT, elle clignote une fois toutes les quelques secondes.

Configuration du module HC-05 :

Ouvrez le moniteur série, réglez le baud rate à 9600 et sélectionnez « Both NL & CR ».

Note : Vous devez le régler sur newline et carriage return, sinon les commandes AT ne marchent pas.

Tapez « AT » dans le moniteur série et vous devriez recevoir « OK ». Si c'est le cas, vous pouvez continuer et donner les commandes comme je l'ai fait.

En gros, nous devons changer ces paramètres en mode AT :

• Supprimer tous les appareils actuellement appairés
• Le faire se connecter uniquement à une adresse MAC Bluetooth spécifiée
• Mettre le mode de connexion Bluetooth à « Maître »
• Spécifier l'adresse MAC à laquelle se connecter
• Régler le baud rate à 115200, stop bit à 2 bits et parité paire

Les instructions ci-dessus étaient données pour que vous puissiez les utiliser même avec un autre module Bluetooth, en vous référant aux commandes et à leur fonction. Mais maintenant, je vais lister les commandes que j'ai données pour que le HC-05 s'appaire avec le Sensor Hub Nano.

• AT+RMAAD
• AT+CMODE=0
• AT+ROLE=1
• AT+BIND=1234,56,abcdef (Remplacez par l'adresse MAC du Sensor Hub Nano)
• AT+UART=115200,0,0

Voici un journal de mes commandes AT pour référence :

Vous devez maintenant débrancher l'Arduino pour éteindre le module Bluetooth. Cela le remettra en mode communication.

Note : Si vous faites une erreur dans les paramètres du HC-05, il serait bon de réinitialiser le module aux paramètres par défaut et recommencer depuis le début avec la commande : AT+ORGL

Test de la connexion :

Maintenant, vous devez tester si l'étape précédente a réussi ; allumez le Sensor Hub Nano. La LED bleue clignotera très lentement, une fois toutes les quelques secondes. Puis branchez votre Arduino sur votre PC, et observez le changement de clignotement des LED sur le HC-05 et le Sensor Hub Nano.

Regardez le clignotement maintenant et comparez avec avant :

Il y a une différence notable, et vous devriez comprendre que les deux modules sont connectés. Vous pouvez maintenant passer à la partie suivante, câbler le projet et le tester.

Note : Si vous avez appairé votre smartphone avec le Sensor Hub Nano avant, vous devrez peut-être le désappairer sinon cela causera des problèmes de connexion. Il ne peut se connecter qu'à un seul dispositif à la fois.

Test du projet de base

Une fois la connexion correcte entre le HC-05 et le Sensor Hub Nano confirmée par les motifs de clignotement des LED, passez à la configuration de l'application Blynk sur smartphone.

Configuration de l'application Blynk :

Téléchargez l'application Blynk (si ce n'est pas déjà fait) pour iOS ou Android ici, et scannez le code QR via l'application Blynk. Elle reproduira automatiquement les widgets de base nécessaires pour l'instant.

Vous verrez un écran similaire :

Ne faites aucune modification ici pour l'instant, continuez la lecture.

Installation des bibliothèques requises :

Vous aurez besoin de deux bibliothèques différentes pour l'Arduino IDE pour compiler sans erreurs :

• Blynk, pour la connexion au smartphone
• u8g2lib, pour l'affichage

Il y a deux façons d'installer les bibliothèques. La première via le « Gestionnaire de bibliothèques » disponible dans les nouvelles versions de l'Arduino IDE, la seconde par installation manuelle. Les deux méthodes sont décrites en détail ici, je ne les détaillerai pas.

Téléversement du code et test :

Une fois les bibliothèques installées, téléchargez le code joint et faites quelques modifications. Vous devrez ajouter votre code d'authentification Blynk (envoyé par email à la création d'un nouveau projet dans Blynk), ainsi que votre SSID et mot de passe WiFi. Une fois fait, téléversez le code sur le MKR1000.

Après le téléversement, câblez le circuit selon le schéma.

Ouvrez l'application Blynk sur votre smartphone, ouvrez le projet Assistant Alzheimer et appuyez sur le bouton play. Branchez le MKR1000 (avec HC-05 et écran câblés), et vous devriez voir le logo « Alzheimer's Assistant » sur l'écran. Il restera un moment, puis vous verrez le message « En attente du Sensor Hub Nano ». Allumez le petit interrupteur sur le Sensor Hub Nano, en vous assurant d'être dans la portée Bluetooth du module HC-05. Il devrait dire « Connecté au Sensor Hub Nano d'Infineon », et après quelques secondes, vous devriez voir les valeurs de pression, température et altitude sur votre smartphone.

Et après quelques secondes, vous verrez aussi l'heure en format 24h, ainsi que la date, synchronisée avec Internet.

Ceci est une vidéo du test :

Si c'est le cas, félicitations, vous avez terminé la partie difficile de la configuration, et maintenant vient la personnalisation pour chaque patient, selon ses préférences.

Personnaliser l'Assistant Alzheimer

Jusqu'ici, ce que nous avons configuré récupère les données du capteur DPS310 d'Infineon dans une configuration propre et élégante, mais pour en faire quelque chose d'utile, nous devons configurer le système selon les besoins et préférences individuels. Dans cette section, je parlerai du code et de comment modifier l'Assistant Alzheimer pour qu'il fonctionne selon les préférences de chaque utilisateur. Je donnerai l'extrait de code pour chaque « fonctionnalité » et vous pourrez simplement l'ajouter dans le code principal avec quelques modifications.

Note : Quand vous regardez le code joint pour le « projet de base », vous verrez qu'il utilise des fonctions enveloppées dans le BlynkTimer. Ce serait une bonne idée de les utiliser si vous voulez faire de la personnalisation, car elles peuvent exécuter des tâches à un intervalle spécifié, et aussi prévenir l'erreur de flood Blynk qui se produit quand votre matériel envoie beaucoup de requêtes à Blynk. De plus, le code est « de base » dans le sens où toutes les fonctions sont présentes mais pas incluses dans le code principal ; l'utilisateur doit éditer le code principal selon ses besoins, et peut-être ajuster l'intervalle de temps auquel chaque fonction s'exécute.

Le DPS310 :

Le DPS310 d'Infineon est un capteur de pression barométrique numérique à bas coût offrant une très haute précision, dans un format très réduit. C'est pourquoi il est parfait pour ce projet, et les valeurs peuvent être utilisées pour détecter les chutes d'un patient âgé, ou dans quelle pièce exacte se trouve le patient.

Note : Je n'ai pas encore fait le boîtier de la montre intelligente, donc j'utilise le Sensor Hub Nano sur ma main, connecté à l'Arduino via Bluetooth, comme sur cette image :

Détection de chute : Pour détecter les chutes, nous devons donner une valeur de chute (la différence de pression atmosphérique entre deux relevés sur un temps donné), et définir une marge. Par exemple, si le changement d'altitude entre deux valeurs successives (sur une durée de, disons, une seconde) est entre la valeur de chute ± la valeur de marge, une chute sera détectée.

J'ai fait quelques tests et trouvé que la valeur de chute devrait être 0.7, et la marge ±0.2, mais cela peut ne pas marcher dans toutes les situations. C'est dû à une raison simple et compréhensible : quand une personne tombe, cela peut se produire de multiples façons. L'utilisation d'un capteur secondaire (probablement un accéléromètre) sera nécessaire pour gagner en précision dans le système de détection de chute, et cela sera ajouté aux travaux futurs. Mais il se pourrait qu'il existe d'autres algorithmes plus précis pour détecter les chutes, et je suis ouvert à les entendre ; n'hésitez pas à commenter si vous avez des idées.

Une vidéo démontrant la détection de chute :

Détecter où se trouve le patient : Cela fonctionne de manière similaire à l'algorithme de détection de chute. Par exemple, si vous devez savoir à quel étage se trouve le patient, vous pouvez prendre la valeur d'altitude actuelle et la soustraire de la précédente. Et comparer la différence à une valeur prédéfinie. Cela indiquera à quel étage se trouve le patient.

Ce ne serait qu'une question de logique if/else simple pour déterminer à quel étage est le patient (les valeurs d'altitude sont déjà dans le code principal). Cela pourrait être indiqué en utilisant les widgets LED dans Blynk.

Note : Je n'ai pas inclus la détection de localisation dans le code principal mais les utilisateurs peuvent l'ajouter selon leurs besoins, n'oubliez pas de l'utiliser comme fonction BlynkTimer.

La même technique pourrait aussi servir à détecter dans quelle pièce se trouve une personne. Dans ce cas, un capteur secondaire comme un détecteur de mouvement serait nécessaire sinon il y aurait beaucoup de faux positifs.

Température : Le DPS310 donne aussi la valeur de température qu'on peut utiliser pour alerter sur tout incident pouvant arriver au patient, par exemple un incendie. Si la température monte à une valeur spécifique, disons 45°C, cela alerte l'aidant.

Mais comme le capteur DPS310 n'est pas attaché directement à la peau (du moins dans ce cas d'usage), ce qu'on obtient n'est pas la température corporelle, mais plutôt la température du Sensor Hub Nano.

Le code pour cela est très simple (utilisable n'importe où dans la boucle principale) :

if (t > maxTemp) {
  // Faire ce que vous voulez si température > maximum
} else {
  // Faire ce que vous voulez si température < maximum
}

Note : Tous les graphiques ci-dessus sont créés avec le logiciel d'évaluation SESG2 fourni par Infineon.

Un buzzer et un interrupteur :

Je n'ai pas mentionné cela avant, mais un buzzer et un interrupteur devraient aussi être présents dans le système et ils seront très utiles. Par exemple, un buzzer pourrait attirer l'attention du patient quand c'est l'heure de prendre ses médicaments, et l'interrupteur pourrait servir de dispositif de sécurité.

Et comme nous utilisons Blynk, le bouton poussoir pourrait être configuré de façon qu'en l'appuyant, une notification apparaisse sur le téléphone de l'aidant ou qu'il appelle ou envoie un SMS (ce qui peut être fait avec IFTTT, voir plus loin). Voici un extrait de code pour cela :

void emailOnButtonPress() {
  // *** ATTENTION : Vous êtes limité à UN SEUL EMAIL PAR 15 SECONDES ! ***
  // Envoie un email quand vous appuyez sur le bouton
  // connecté à la broche digitale 2 sur votre Arduino
  int isButtonPressed = !digitalRead(2); // Inverse l'état, bouton "Active LOW"
  if (isButtonPressed) {
    Serial.println("Bouton appuyé.");
    Blynk.email("votre_email@mail.com", "Sujet: Bouton", "Vous venez d'appuyer sur le bouton...");
    // Ou, pour utiliser l'email spécifié dans l'App (pour export App) :
    // Blynk.email("Sujet: Bouton", "Vous venez d'appuyer sur le bouton...");
  }
}

Ce code est tiré de l'exemple Blynk, et utilise une interruption pour vérifier le bouton. Cela pourrait être utilisé par le patient pour alerter l'aidant en cas d'urgence, comme une chute non détectée par l'algorithme. Vous pouvez obtenir le code complet d'exemple ici, qui envoie un email à chaque appui sur le bouton.

Le buzzer pourrait produire des tons (commande Arduino tone() - plus d'infos ici), pour rappeler au patient une tâche comme la médication ou l'exercice.

L'Affichage :

Une partie majeure du projet, que l'utilisateur regarde réellement, est l'affichage. Les écrans Nokia 5110 sont courants, faciles à configurer et peu chers, mais ils ne sont pas très flashy, surtout dans un tel système. Les écrans OLED à plus haute résolution seront une excellente alternative, et vous pouvez facilement modifier le code pour qu'il fonctionne avec l'un d'eux car j'ai utilisé la bibliothèque u8g2 (GitHub ici). Choisissez n'importe quel modèle d'affichage ici, et ajoutez-le au début du sketch (en supprimant la ligne Nokia 5110, bien sûr !). Vous devrez le câbler selon ce qui est dans le code et c'est prêt. Vous pouvez aussi utiliser des images bitmap avec un affichage à plus haute résolution. Vous pouvez aussi changer la police du texte sur l'affichage, choisissez dans l'énorme liste ici et modifiez le nom de la police dans le code.

Note : Vous devrez peut-être changer les positions en pixels pour le texte dans le code si vous utilisez un affichage à plus haute résolution.

C'était juste une brève description de la bibliothèque pour faire fonctionner l'affichage. Mais maintenant, je vais vous dire comment éditer le code pour que l'Assistant Alzheimer affiche l'heure ou les données du Sensor Hub Nano (température, altitude, pression).

Afficher l'heure : Pour afficher l'heure, vous pourriez utiliser un module RTC, mais comme nous sommes connectés à Internet, ce serait bien plus simple d'utiliser Internet pour synchroniser l'heure. Et comme nous utilisons Blynk, c'est encore plus simple. Il vous faut juste le widget RTC dans votre projet. Maintenant, avec quelques lignes de code, vous pouvez récupérer automatiquement l'heure du serveur Blynk (Assurez-vous de régler votre fuseau horaire depuis le widget Blynk). Le code principal est configuré pour afficher l'heure par défaut (pas les valeurs du capteur, discutées ensuite).

Note : L'heure affichée à l'écran pourrait varier d'une minute, car elle est synchronisée depuis Internet, mais malgré cela, je l'ai testée longtemps et l'ai trouvée très précise (juste quelques secondes de différence).

Afficher les données du Sensor Hub Nano : Nous pourrions tout aussi bien afficher les données du Sensor Hub Nano sur l'écran. Pas que cela profite au patient, mais c'est bien pour le débogage, si nécessaire. Cela peut se faire avec l'extrait de code suivant :

void showSensorValues() {
  char bufT[10], bufP[10], bufA[10];
  String(t).toCharArray(bufT, 10);
  String(p).toCharArray(bufP, 10);
  String(a).toCharArray(bufA, 10);
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf);
  // Température
  u8g2.drawStr(0, 10, "T:");
  u8g2.drawStr(12, 10, bufT);
  u8g2.drawStr(73, 10, "C");
  u8g2.drawCircle(70, 4, 1, U8G2_DRAW_ALL);
  u8g2.drawHLine(0, 12, 85);
  // Pression
  u8g2.drawStr(0, 26, "P:");
  u8g2.drawStr(12, 26, bufP);
  u8g2.drawStr(60, 26, "mBar");
  u8g2.drawHLine(0, 28, 85);
  // Altitude
  u8g2.drawStr(0, 42, "A:");
  u8g2.drawStr(12, 42, bufA);
  u8g2.drawStr(72, 42, "m");
  u8g2.drawHLine(0, 44, 85);
  u8g2.sendBuffer();
}

N'oubliez pas d'exécuter cette commande pour obtenir les données du capteur :

getSensorValues();

Mais ce n'est pas tout pour l'affichage. Comme je l'ai dit au début, l'Assistant Alzheimer doit pouvoir rappeler au patient les tâches quotidiennes, comme quand prendre ses médicaments ou faire de l'exercice.

Utiliser le widget Eventor pour les rappels :

Pour cela, nous utiliserons le widget Eventor (voir détails ici) dans Blynk.

Ajoutez le widget Eventor dans votre projet (il est déjà là si vous avez scanné le QR code ci-dessus), et suivez les captures d'écran pour voir comment le configurer :

Dans l'exemple ci-dessus, le widget Eventor est utilisé pour configurer une notification de détection de chute.

Utiliser le widget Eventor pour les rappels se fait par ce code :

BLYNK_WRITE(vEVENTOR_PIN) {
  int currentValue = param.asInt(); // 0 à 1
  if (currentValue == 1) {
    showPillReminder();
    playBuzzerReminder(); // Juste un ton, pas dans le code principal mais vous pouvez l'ajouter !
  } else {
    // Si ce n'est pas l'heure des médicaments, ne rien faire
  }
}

Résultat sur l'affichage quand c'est l'heure des médicaments :

Pareil pour l'exercice :

Cela se fait en tapant :

showExerciseReminder();

Au lieu de :

showPillReminder();

Le widget Eventor pourrait, comme dit plus haut, servir à beaucoup de choses. Par exemple, vous pourriez configurer qu'une augmentation de température entraîne l'envoi d'un email, sans modification de code !

Utiliser différents modes du Sensor Hub Nano :

Vous pouvez tester l'utilisation de différents modes pour le Sensor Hub Nano avec les commandes :

sendCommand(LOW_ENERGY);
sendCommand(STANDARD_MODE);
sendCommand(HIGH_PRECISION);

Utiliser Blynk pour changer de mode pourrait être plus efficace. Configurez votre application Blynk comme ceci :

Comme cela n'avait pas d'utilité pour moi, je ne l'ai pas ajouté dans le code principal, mais vous pouvez toujours le faire selon vos besoins (les commandes sont présentes, il suffit de les ajouter avec un peu de logique dans le sketch principal).

Utiliser Blynk et IFTTT :

Blynk permet à tout projet Arduino d'exploiter facilement la puissance d'IFTTT.

C'est parce que vous pouvez utiliser Blynk pour envoyer une requête webhook vers le canal IFTTT Webhooks (anciennement Maker channel), et créer un applet IFTTT qui attend le déclenchement du webhook (depuis Blynk et Arduino) et déclenche n'importe quoi d'autre en réponse.

Exemple simple d'utilisation d'IFTTT et Blynk avec webhooks :

Le widget webhook Blynk pourrait envoyer une requête webhook comme ceci :

Voici le canal webhook IFTTT :

Et utiliser les webhooks pour déclencher IFTTT n'est pas la seule méthode. IFTTT peut aussi être déclenché en utilisant Blynk pour envoyer des emails et des tweets.

Vous avez maintenant créé un applet. Temps de le tester.

Ouvrez « Services » dans IFTTT puis sélectionnez « Webhooks ». Allez dans « Settings » et vous verrez une URL. Copiez-la et ouvrez-la dans un nouvel onglet. Là, au lieu de {event}, tapez le nom de l'événement (que vous avez défini plus tôt). C'était « button_pressed » pour moi, et quand je clique sur « Test it », voici le résultat après quelques secondes :

Maintenant que vous avez confirmé que le Webhook fonctionne, vous pouvez simplement écrire l'URL dans les paramètres du webhook Blynk et obtenir une requête GET ou POST (via le widget webhook Blynk).

Et, au lieu de SMS, vous pourriez tout aussi bien utiliser des appels téléphoniques, ou même Twitter et Facebook, si vous voulez, et c'est tout aussi simple. C'est la puissance d'IFTTT.

C'est la même chose que mon projet de contrôle domotique intelligent ici, et j'en ai aussi discuté en détail là-bas, mais c'est une chose géniale que je ne pouvais pas passer sous silence.

Touches finales

Maintenant, presque toute la partie électronique du projet est terminée, mais il reste quelques choses. Lisez la suite, et à la fin, je listerai les travaux futurs pour améliorer ce projet.

Batterie et charge :

Le MKR1000 a un port pour batterie LiPo, vous pouvez donc en brancher une. Je n'en ai pas pour le moment donc je n'irai pas dans les détails, mais consultez le site de l'Arduino MKR1000 si vous avez besoin d'infos.

Pour la charge, vous avez deux options : utiliser le port USB du MKR1000 directement, ou utiliser la charge sans fil si vous l'avez. J'utiliserai la charge sans fil car j'ai déjà un récepteur et un émetteur de charge sans fil de Futara Elettronica.

Pour utiliser le récepteur et l'émetteur, il suffit de fournir la tension spécifiée à l'émetteur. Ce sera le « dock » où vous pourrez placer l'Assistant Alzheimer pour le charger. Côté récepteur, il suffit de couper et brancher un câble USB micro B de rechange (qui va au port USB du MKR1000) et connecter l'autre côté à VCC et masse en regardant le pinout.

Regardez les images ci-dessous pour voir comment câbler :

Et le résultat final :

Le Boîtier :

Comme pour tout projet, un boîtier est nécessaire, et voici comment je veux que l'Assistant Alzheimer ressemble :

Note : Je n'ai pas encore accès à une découpeuse laser ou imprimante 3D, donc le fichier STL est juste pour montrer à quoi ressemble le projet final et n'est pas à l'échelle.

Ceci conclut la documentation de l'Assistant Alzheimer, mais je voulais quand même inclure la section travaux futurs pour décrire les choses que je voulais vraiment faire pour le projet, mais que je n'ai pas pu, pour une raison ou une autre.

Travaux futurs :

Comme je l'ai dit, ce sont les choses que je voulais inclure dans le projet, que j'ajouterai dans le futur, si j'ai le temps :

• Fabriquer un vrai boîtier. Pour l'instant je teste sur breadboard mais si j'ai accès à une découpeuse laser ou imprimante 3D, je mettrai à jour la documentation.
• Utiliser un module Bluetooth 4.0 au lieu de celui-ci.
• Ou encore mieux, utiliser directement le capteur DPS310 au lieu du Sensor Hub Nano. Cela réduirait le coût global, en éliminant le Sensor Hub Nano et le module Bluetooth ; le DPS310 est lui-même peu cher. Il s'agit de modifier le code principal pour récupérer température, pression et altitude du DPS310 seulement, le reste est fait.
• Utiliser un capteur secondaire pour travailler avec le DPS310 pour la détection de chute et la détection de localisation. Cela réduirait les fausses alertes positives et négatives. Probablement un accéléromètre et un détecteur de mouvement seront nécessaires pour les deux.
• Ajouter un capteur de pouls. Je n'en avais pas, donc je n'ai pas pu l'ajouter. Ce serait un excellent ajout.
• Utiliser un affichage à plus haute résolution, de préférence OLED. Avec cela, des graphiques pourraient être inclus et ce serait sympa.
• Travailler sur l'amélioration de l'autonomie de la batterie. Cela peut se faire en utilisant un mode sommeil profond dans le MKR1000, mais je ne l'ai pas encore utilisé dans le code.

Merci d'avoir lu, et j'espère que mon projet vous a plu. N'hésitez pas à me donner vos avis et idées sur le projet.

Code

Commandes AT

// Sketch original du blog de Martyn Currey :
// https://www.martyncurrey.com/arduino-with-hc-05-bluetooth-module-at-mode/
//
// Sketch modifié par moi pour fonctionner avec Arduino MKR1000 !
//
// Sketch Bluetooth de base
// Connectez le module HC-05 et communiquez via le moniteur série
//
// Le HC-05 démarre en mode communication par défaut.
// Doit être mis en mode AT
// Après reset usine, le baud rate par défaut pour le mode communication est 38400
char c = ' ';
void setup() {
  Serial.begin(9600);
  Serial.println("Arduino avec HC-05 prêt");
  Serial1.begin(38400);
  Serial.println("Serial1 démarré à 38400");
}
void loop() {
  if (Serial1.available()) {
    c = Serial1.read();
    Serial.write(c);
  }
  if (Serial.available()) {
    c = Serial.read();
    Serial.write(c);
    Serial1.write(c);
  }
}

Assistant Alzheimer

// Bibliothèques requises
#include <BlynkSimpleMKR1000.h>
#include <WidgetRTC.h>
#include <WiFi101.h>
#include <Arduino.h>
#include <U8g2lib.h>
#include <SPI.h>

// Obtenez le Auth Token dans l'app Blynk.
// Allez dans Project Settings (icône écrou).
char auth[] = ""; // Entrez votre token Blynk ici
// Vos identifiants WiFi.
// Mettez password à "" pour réseaux ouverts.
char ssid[] = "";
char pass[] = "";

// Commandes Sensor Hub Nano
#define HELLO "$hello id="
#define INFO "$info id="
#define SENSOR_INFO "$sinfo id=1"
#define LOW_ENERGY "$set_mode sid=1;md=mode;val=bg"
#define STANDARD_MODE "$set_mode sid=1;md=prs_osr;val=16"
#define HIGH_PRECISION "$set_mode sid=1;md=prs_mr;val=32"
#define START "$start_sensor id=1"
#define STOP "$stop id="

// Seuils détection chute et marge
#define FALL 0.7
#define CLEARANCE 0.2

// Broches virtuelles Blynk
#define vTEMPERATURE_PIN V0
#define vPRESSURE_PIN V1
#define vALTITUDE_PIN V2
#define vEVENTOR_PIN V3
#define vFALL_PIN V4

// Variables
float t, p, a, previousA;
boolean fallState;
unsigned long previousMillis = 0;
const long interval = 1000;
boolean BTconnected = false;
int btStatePin = 9;
int backlightPin = 2;

BlynkTimer timer;
WidgetRTC rtc;

// Écran Nokia 5110
U8G2_PCD8544_84X48_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 7, /* data=*/ 8, /* cs=*/ 3, /* dc=*/ 5, /* reset=*/ 4);

void setup() {
  Serial.begin(115200);
  Serial1.begin(115200);
  timer.setInterval(1000L, sendSensorValues);
  timer.setInterval(3000L, showTimeAndDate);
  pinMode(btStatePin, INPUT);
  pinMode(backlightPin, OUTPUT);
  digitalWrite(backlightPin, LOW);
  u8g2.begin();
  showStartMessage();
  delay(2000);
  while (!BTconnected) {
    if (digitalRead(btStatePin) == HIGH) {
      BTconnected = true;
    } else {
      showWaitingFor();
    }
  }
  initSensorHub();
  Blynk.begin(auth, ssid, pass);
  rtc.begin();
  setBlynkWidgets();
  showTimeAndDate();
  sendCommand(START);
}

void loop() {
  Blynk.run();
  timer.run();
  getSensorValues();
  checkIfFalling();
}

void sendCommand(String sensorCommand) {
  Serial1.println(sensorCommand);
}

void initSensorHub() {
  String junkVal;
  sendCommand(INFO);
  while (Serial1.find("IFX_NanoHub") == false) {
    sendCommand(INFO);
    Serial.println("ERREUR");
    showErrorMessage();
  }
  junkVal = Serial1.readStringUntil('\n');
  junkVal = "";
  showConnectedMessage();
  delay(1500);
}

void getSensorValues() {
  String junkVal;
  if (Serial1.available()) {
    junkVal = Serial1.readStringUntil('\n');
    junkVal = Serial1.readStringUntil('t');
    t = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('p');
    p = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('a');
    a = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('\n');
  }
}

void sendSensorValues() {
  Blynk.virtualWrite(vTEMPERATURE_PIN, t);
  Blynk.virtualWrite(vPRESSURE_PIN, p);
  Blynk.virtualWrite(vALTITUDE_PIN, a);
}

void checkIfFalling() {
  unsigned long currentMillis = millis();
  if ((currentMillis - previousMillis) >= interval) {
    float diff = previousA - a;
    if ((diff >= (FALL - CLEARANCE)) && (diff <= (FALL + CLEARANCE))) {
      fallState = true;
      Serial.println("Chute détectée");
      showFallMessage();
      Blynk.virtualWrite(vFALL_PIN, 255);
    }
    previousA = a;
    previousMillis = currentMillis;
    fallState = false;
    Blynk.virtualWrite(vFALL_PIN, 0);
  }
}

void showStartMessage() {
  u8g2.clearBuffer();
  u8g2.drawRFrame(3, 7, 75, 31, 7);
  u8g2.setFont(u8g2_font_prospero_bold_nbp_tf);
  u8g2.drawStr(8, 19, "Alzheimer's");
  u8g2.drawStr(12, 35, "Assistant");
  u8g2.sendBuffer();
}

void showWaitingFor() {
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_prospero_bold_nbp_tf);
  u8g2.drawStr(9, 15, "Waiting for");
  u8g2.drawStr(8, 28, "Sensor Hub");
  u8g2.drawStr(22, 41, "Nano !!!");
  u8g2.sendBuffer();
}

void showConnectedMessage() {
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_7x13B_tf);
  u8g2.drawStr(0, 10, "Connected to");
  u8g2.drawStr(8, 22, "Infineon's");
  u8g2.drawStr(7, 34, "Sensor Hub");
  u8g2.drawStr(29, 46, "Nano");
  u8g2.sendBuffer();
}

void showErrorMessage() {
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_fub14_tf);
  u8g2.drawStr(9, 30, "ERROR");
  u8g2.sendBuffer();
}

void showSensorValues() {
  char bufT[10], bufP[10], bufA[10];
  String(t).toCharArray(bufT, 10);
  String(p).toCharArray(bufP, 10);
  String(a).toCharArray(bufA, 10);
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.drawStr(0, 10, "T:");
  u8g2.drawStr(12, 10, bufT);
  u8g2.drawStr(73, 10, "C");
  u8g2.drawCircle(70, 4, 1, U8G2_DRAW_ALL);
  u8g2.drawHLine(0, 12, 85);
  u8g2.drawStr(0, 26, "P:");
  u8g2.drawStr(12, 26, bufP);
  u8g2.drawStr(60, 26, "mBar");
  u8g2.drawHLine(0, 28, 85);
  u8g2.drawStr(0, 42, "A:");
  u8g2.drawStr(12, 42, bufA);
  u8g2.drawStr(72, 42, "m");
  u8g2.drawHLine(0, 44, 85);
  u8g2.sendBuffer();
}

void showFallMessage() {
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_7x13B_tf);
  u8g2.drawStr(27, 20, "Fall");
  u8g2.drawStr(13, 32, "Detected!");
  u8g2.sendBuffer();
  delay(1000);
}

void showPillReminder() {
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_7x13B_tf);
  u8g2.drawStr(0, 20, "Time to take");
  u8g2.drawStr(5, 32, "your pills!");
  u8g2.sendBuffer();
}

void showExerciseReminder() {
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_7x13B_tf);
  u8g2.drawStr(16, 20, "Time to");
  u8g2.drawStr(12, 32, "exercise!");
  u8g2.sendBuffer();
}

void showTimeAndDate() {
  if (year() == 1970) {
    // Serial.println("Heure pas encore synchronisée");
  } else {
    char bufHours[3], bufColon[2], bufMinutes[3], bufDate[11];
    String currentHours = String(hour());
    String colon = ":";
    String currentMinutes = String(minute());
    String currentDate = String(day()) + "/" + month() + "/" + year();
    String(currentHours).toCharArray(bufHours, 3);
    String(colon).toCharArray(bufColon, 2);
    String(currentMinutes).toCharArray(bufMinutes, 3);
    String(currentDate).toCharArray(bufDate, 11);
    u8g2.clearBuffer();
    u8g2.setFont(u8g2_font_inr33_mf);
    u8g2.drawStr(30, 30, bufColon);
    u8g2.setFont(u8g2_font_logisoso32_tn);
    u8g2.drawStr(0, 32, bufHours);
    u8g2.drawStr(45, 32, bufMinutes);
    u8g2.setFont(u8g2_font_saikyosansbold8_8n);
    u8g2.drawHLine(0, 35, 85);
    u8g2.drawStr(0, 46, bufDate);
    u8g2.sendBuffer();
  }
}

BLYNK_WRITE(vEVENTOR_PIN) {
  int currentValue = param.asInt();
  if (currentValue == 1) {
    showPillReminder();
  } else {
    // Serial.println("Pas l'heure des pilules");
  }
}

void setBlynkWidgets() {
  Blynk.setProperty(vTEMPERATURE_PIN, "color", "#FFFFFF");
  Blynk.setProperty(vPRESSURE_PIN, "color", "#00BBFF");
  Blynk.setProperty(vALTITUDE_PIN, "color", "#FFFF00");
}

BLYNK_CONNECTED() {
  rtc.begin();
}

Pièces personnalisées et boîtiers

Ceci est juste pour montrer comment je veux que le boîtier ressemble. Ce n'est pas du tout à l'échelle !

Schémas

Ce schéma est utilisé pour mettre votre HC-05 en mode AT et le configurer, en utilisant l'Arduino MKR1000.

Schéma Fritzing pour le projet de base

Document listant les commandes AT pour le HC-05