Distributeur de pilules intelligent

Outils et machines nécessaires

	Imprimante 3D (générique)
	Fer à souder (générique)
	Fil à souder, sans plomb

Applications et services en ligne

	Microchip Technology MPLAB X IDE
	Arduino IDE
	Autodesk Fusion 360
	Amazon Web Services AWS IoT
	Amazon Web Services AWS DynamoDB
	Passerelle Amazon Web Services AWS API
	Amazon Web Services AWS Lambda
	Microsoft VS Code

À propos de ce projet

Pourquoi ce projet ?

Il existe actuellement sur le marché deux types de piluliers :les non électriques et les automatiques. Bien que la majorité d'entre eux disposent d'un mécanisme de rappel (pas toujours adapté aux personnes déficientes visuelles ou sensorielles), les deux types nécessitent normalement une personne qui organise les pilules quotidiennement ou hebdomadairement dans différents compartiments, faisant du patient une personne dépendante. De nos jours en raison du Covid-19, les membres de la famille ou les assistants aux personnes âgées ont plus de difficultés à s'occuper des personnes dépendantes.

C'est pourquoi nous avons vu la nécessité de créer un pilulier intelligent qui n'a pas besoin d'une organisation de pilules à la main, accessible aux personnes handicapées, et a la capacité d'aider les patients à être plus indépendants.

Ci-dessous, nous vous montrons les 10 meilleurs piluliers de 2020 :

Comme vous pouvez le voir, il y a beaucoup à améliorer dans le monde des piluliers. Et c'est exactement ce que SmartPill va résoudre.

Comment ça marche ?

Le système SmartPill est composé de 2 sous-systèmes :

• Distributeur Smartpill : Dispositif physique qui organisera, stockera et distribuera les pilules. Il servira d'interface principale pour le patient.
• Application Web Smartpill : Interface utilisateur Web qui permettra au médecin ou à la personne responsable du patient de configurer et de suivre les admissions de patients.

À l'aide de l'application Web dotée d'une interface utilisateur agréable et conviviale, le médecin peut configurer jusqu'à 4 pilules différentes pour chaque distributeur Smartpill et sélectionnera jusqu'à 3 prises par jour pour chaque pilule. Cela permet au médecin de modifier la posologie à distance chaque fois que cela est nécessaire sans l'intervention du patient lui-même.

Le système SmartPill a été conçu en tenant compte des difficultés que peut avoir un patient atteint de démence sénile, d'Alzheimer ou de déficience visuelle ou auditive. Pour cette raison, le distributeur dispose d'un écran grand format qui permettra au patient de remplir les pilules de manière confortable ainsi qu'un retour sonore et lumineux qui rappellera au patient de prendre les pilules juste au bon moment.

L'utilisateur n'a pas à se soucier de l'endroit ou de la manière dont les différentes pilules doivent être mises. C'est parce qu'il existe un mécanisme intelligent qui distribue les pilules à l'intérieur du pilulier et distribue la dose nécessaire au bon moment.

SmartPill Dispenser dispose d'une connexion Internet sans fil au cloud AWS grâce à la connexion WiFi de la carte Microchip AVR-IoT, de sorte qu'elle peut être surveillée et configurée à distance via l'application Web.

L'application indiquera également quand les pilules ont été prises et informera le membre de la famille si la pilule n'est pas prise.

Distributeur SmartPill

Système de distribution

Vous vous demandez peut-être comment fonctionne le système de distribution ? Cette section montre toutes les différentes parties et explique leur fonctionnalité.

Il faut préciser qu'outre l'écran, tout a été imprimé en 3D avec du PLA Plastic. Vous pouvez également consulter le fichier .STL de l'ensemble du distributeur disponible ci-dessous.

1. Base :Il supporte le reste du distributeur. Il a deux trous afin de rendre le capteur de mouvement fonctionnel. Il contient un rabat qui amène les pilules dans la tasse.

2. Curseur :Le haut du curseur supporte les piluliers. En dessous, il y a une pente dans laquelle les pilules descendent jusqu'au rabat. En bas, il y a un espace préparé pour y mettre toute l'électronique.

3. Parties latérales :Utilisé pour protéger le matériel et les pilules de l'humidité, des températures, de la saleté et de la poussière.

4. Nextion NX8048T070 :Écran utilisé comme interface entre le distributeur et l'utilisateur.

5. Parties supérieures :

• Utilisé pour protéger le matériel et les pilules de l'humidité, des températures, de la saleté et de la poussière (en haut).
• Sépare le tambour des piluliers (en bas).

6. Servo de parallaxe 900-0005 :moteur électrique 360º qui met dans la bonne position la référence 7.

7. Tambour :Tube de liaison entre l'extérieur et les piluliers. Il tourne afin d'arriver au bon conteneur.

8. Porte arrière :Nécessaire pour entrer et sortir des piluliers avec le curseur.

9. Conférenciers :Ils communiqueront à l'utilisateur toutes les informations nécessaires.

10. Capteur à ultrasons - HC SR04 :Cet appareil détectera si la tasse a été éloignée.

11. Pilulier :Ils contiennent les pilules et ils les distribuent au bon moment avec la bonne quantité. Comme prototype, nous avons conçu le pilulier avec 4 récipients. Cependant, il peut être adapté à une plus grande capacité.

Voulez-vous votre propre distributeur SmartPill ? Allez télécharger les fichiers STL en bas et imprimez toutes les pièces avec votre imprimante 3D ! Le projet est entièrement open-source.

Dans la section suivante, nous expliquerons étape par étape comment assembler le système de distribution.

Assemblage

• Afin d'imprimer en 3D le Slider (Partie 2 - Dessin général) nous l'avons divisé en trois parties. Donc, tout d'abord, nous l'assemblons. Choisissez les noix (2.3.2 - Dessin de curseur ) et placez-les dans le Slider (2.2 - Dessin de curseur ) avec un soudeur. Puis vissez les deux pièces (2.3.1 &2.2 - Dessin de curseur ). Attendez de mettre le bouchon (2.4 - Dessin de curseur) jusqu'à ce que l'électronique soit câblée.

• Mettez l'électronique à l'intérieur de l'espace du curseur, y compris le Capteur à ultrasons - HC SR4 (Partie 10- Dessin général) et vissez le couvercle du curseur (2.4).
• Assemblez les conteneurs de pilules (regardez le Dessin des conteneurs de pilules ) avec un servo SG90 chacun. Rejoignez d'abord la partie 1 avec la partie 7 et vissez le SG90 à la Partie 7 . Ensuite, joignez la partie 3 à la partie 4 (roulement de roue) et ajoutez enfin la partie 2. Vissez ensuite les piluliers sur le dessus du curseur (Partie 2 - Dessin général) .

• Vissez l'écran (Partie 4 - Dessin général). sur la partie latérale appropriée et installez le bouchon. Et ensuite assembler les pièces Sider (Partie 3 - Dessin général) à la base jusqu'à ce qu'ils cliquent.
• Il y a deux parties supérieures ( (Partie 5 - Dessin général) . Nous les assemblons en reprenant les écrous et en les emboîtant dans les pièces. Cette fois, aucun soudeur n'est nécessaire. Monter le tambour (Partie 7 - Dessin général) et le Servo Parallax (Partie 6- Dessin général) entre eux et nous vissons les deux parties supérieures ensemble.
• Enfin visser la porte arrière (Partie 8 - Dessin général) à l'assemblage de la partie supérieure.

Électronique

Le cerveau électronique principal est un Arduino Mega qui se chargera de contrôler les servomoteurs qui distribuent les pilules, ainsi que l'écran tactile Nextion, l'horloge temps réel (RTC), les effets sonores et la carte de communication AVR-IoT.

• AVR-IoT est connecté à l'Arduino Mega au moyen d'une connexion série UART.
• Les servomoteurs sont contrôlés par PWM.
• RTC est connecté à l'Arduino Mega par I2C.
• Le capteur de barrière IR pour détecter les pilules est connecté aux broches analogiques de la carte Arduino.

Afin de reproduire le projet, vous devez effectuer toutes les connexions décrites dans le schéma à l'aide d'une carte proto ou d'un PCB fabriqué par vous-même. Nous vous recommandons fortement de monter le circuit dans une sorte de plaque de bois comme dans l'image ci-dessus.

Le schéma se trouve à la fin de la page.

Application Web SmartPill

L'application Web SmartPill vise à faciliter l'expérience qui implique la configuration d'un appareil électronique et le contrôle des médicaments de quelqu'un d'autre.

• Un distributeur SmartPill facile à configurer, avec les informations du patient, les pilules qui doivent être prises, le dosage nécessaire et l'intervalle de temps.
• Surveillance de la prise de pilules.

Comment a-t-il été développé ?

Pour développer un site Web dès le départ, vous travaillez avec les domaines fondamentaux de la programmation :backend et frontend. La WebApp Smartpill a été créée avec :

• Backend. Passerelle d'API AWS (HTTT API Rest).
• Front-end. Ionique &Angulaire. Pour développer un site Web dès le départ, vous travaillez avec les domaines fondamentaux de la programmation :backend et frontend.

Ionic est un framework NodeJS entièrement gratuit et open source basé sur AngularJS qui fournit des éléments d'interface utilisateur spécifiques à la plate-forme via une bibliothèque de composants natifs pour iOS et Android. Il utilise des technologies frontales telles que HTML, CSS, JavaScript et Angular pour le développement d'applications. Ionic peut utiliser Angular CLI (Command-Line Interface) pour créer des applications mobiles entièrement fonctionnelles.

N'oubliez pas qu'avant de démarrer votre site Web avec Ionic, Node.js doit être installé pour fonctionner, car Ionic fait partie d'un vaste écosystème JavaScript.

La page Ionic Framework Documentation peut vous guider sans problème au démarrage de votre application. Cependant je mentionnerai brièvement les premières étapes suivies pour la création de l'application Smartpill :

1. Accédez à la ligne de commande de votre éditeur de code et installez ionic CLI avec npm :

$ npm install -g @ionic/cli 

2. Créez une nouvelle application :

$ ionic start smartpill-webui blank 

3. Allez dans le dossier de votre frontend et lancez-le :

$ cd smartpill-webui
$ service ionique 

L'exécution de votre application signifie que vous pouvez la tester dans le navigateur de votre appareil. Cette fonction ionique est essentielle pour le débogage et les tests.

Structure de base de l'application Web Smartpill.

L'application Web Smartpill est organisée de manière simple, pour simplifier la navigation. Dans les dossiers de l'application, nous pouvons trouver le module de routage de l'application, les fichiers des composants de l'application, un dossier « services » et un dossier pour chaque itinéraire.

Si vous n'avez jamais touché aux technologies frontend, vous remarquerez dans l'aperçu de ce code comment les différents langages interagissent les uns avec les autres. Mais si nous devions décrire brièvement son fonctionnement, la partie du Web que vous verrez est le fichier html du dossier, tandis que le fichier dactylographié correspond aux fonctions qui s'exécutent lorsque l'utilisateur interagit avec la page. Les modules.ts sont à des fins de routage.

Les fichiers les plus essentiels de l'application Smartpill sont :

• app-routing.module.ts. Il permet à l'utilisateur de naviguer à travers tous les différents itinéraires disponibles. Certains chemins permettent au développeur Web de transporter des variables d'une route à une autre.

routes const :Routes =[
 {
 chemin :'',
 redirectTo :'page-login',
 pathMatch :'full'
 },
 {
 chemin :'page-config',
 loadChildren:() => import('./page-config/page-config.module').then( m => m.PageConfigPageModule)
 },
 {
 chemin :'page-status',
 loadChildren:() => import('./page-status/page- status.module').then( m => m.PageStatusPageModule)
 },
... 

• post.service.ts. Il communique avec l'API. Ici, les interfaces principales sont définies (Post, Dep et Log), ainsi que la classe PostService. PostService a les principales fonctions de base pour communiquer avec l'API :fonction get, pour recevoir des informations de l'API; poster, pour créer un nouvel article dans l'API ; supprimer, pour supprimer un article ; et put, pour éditer un article existant dans l'interface, mais en supprimant les données précédentes qu'il contenait.

getPosts() {
 return this.http.get(this.API);
 }

 getDeposit() {
 renvoie this.http.get(this.DEPOSIT);
 }

 
 getLogs(){
 renvoie this.http.get (this.LOGS);
 }

 createPost(pilule :chaîne, dépôt :chaîne, poids :chaîne, matin :booléen, après-midi :booléen, nuit :booléen) {
 retourne this.http.post(this.API, {
 pilule,
 dépôt,
 poids,
 matin,
 après-midi,
 nuit,
 });
 }

 removePost(id:string) {
 return this.http.delete(` ${this.API}/${id}`);
 }
... 

Configuration et modification de la page de la pilule.
Smartpill a un itinéraire dédié pour afficher tous les messages programmés appelé « page-config ». Pour créer un nouveau message pour configurer les pilules, l'utilisateur doit appuyer sur un bouton dans le coin inférieur droit qui les redirigera vers la page d'édition « page-éditer-pilule ». Cependant s'ils ne veulent pas créer mais éditer, en appuyant sur le bouton éditer d'un post déjà créé, le web les redirigera aussi vers la « page-edit-pill » mais portant l'identifiant du post. Ces deux déclarations sont définies comme suit :

• Créer un nouveau bouton de publication

• Bouton Modifier la publication

 
 Modifier
 

La page "page-edit-pill" reconnaît si l'utilisateur a entré l'itinéraire avec ou sans identifiant, et exécute les fonctions correspondantes à l'aide de simples ifs.

• Chemin avec Id défini dans le module de route

{
 path:'pill/edit/:postId',
 loadChildren:() => import('./page-edit-pill/page-edit-pill.module ').then( m => m.PageEditPillPageModule)
}, 

• Lecture si l'itinéraire porte un identifiant

ngOnInit() {
 this.actiavtedRoute.paramMap.subscribe((paramMap) => {
 if(ParamMap.get("postId")) {
 this. postService
 .getPostById(paramMap.get("postId"))
 .subscribe((res) => {
 this.post =res;
 this.editing =true; 
 });
 }
 });
} 

• Si exemple d'affichage

 {{modification ?
 'Mettre à jour votre' :
 'Créer votre'
 }} Dépôt
 

• Exemple de bouton If

 {{editing ? 'Mettre à jour' :'Envoyer'}}
 

La « page d'édition-pilule » interagit avec l'utilisateur avec des composants d'interface utilisateur ioniques tels que des entrées et des sélections, qui seront envoyés ultérieurement à l'API :

• Sélection multiple temporelle

 Cliquez ici pour sélectionner l'heure.
  cancelText="Annuler" okText="Submit">
 Matin
 Après-midi
 Nuit
 
 

• Entrée de pilule

 Nom de la pilule :
 
 

La "page de configuration" a été programmée avec Angular Life Cycle, donc lorsque vous revenez de la "page-edit-pill" ou de tout autre, la page sera actualisée et les publications se rechargeront, mettant à jour les modifications automatiquement.

• Charger la fonction de publication

loadPosts(){
 this.postService.getPosts().subscribe(
 (res) => {
 this.posts =res;
 }, 
 (err) => console.log(err)
 );
 this.postService.getDeposit().subscribe(
 (res) => {
 this .dep =res; 
 console.log(this.dep);
 };
 (err) => console.log(err)
 ); 

La « page de configuration » a également un bouton qui permet à l'utilisateur de supprimer n'importe quelle pilule. C'est une fonction asynchrone qui affiche un message d'alarme pour vérifier s'ils sont sûrs de cette action.

• Suppression d'un message

async removePost(id :string){
 const alert=wait this.alertController.create({
 header :"Alert",
 subHeader :"Êtes-vous sûr que vous voulez supprimer ce dépôt ?",
 message :"Vous ne pourrez pas le récupérer.",
 boutons :[
 "Annuler",
 {
 texte :"Oui",
 gestionnaire :() => {
 this.postService.removePost(id).subscribe(
 (res) => {
 console.log (res);
 this.loadPosts();
 },
 (err) => console.log(err)
 );
 },
 },
 ],
 });
 wait alert.present();
} 

Page des journaux

La page des journaux récupère les informations sur les pilules distribuées et les affiche sous forme de journal sur l'itinéraire de l'historique. Cela fonctionne de manière similaire à "config-page" mais il ne charge que les informations situées dans l'API :

• Obtenir des journaux

loadPosts() {
 this.postService.getLogs().subscribe(
 (res) => {
 this.log =res;
 console. log(this.log);
 },
 (err) => console.log(err)
 );
}

ngOnInit() {
 this.loadPosts();
}

ionViewWillEnter(){
 this.loadPosts();
} 

• Affichage des journaux

 
 
 
 
 
 
 
{{ log.date | date :'jj/MM/aaa' }} - {{ log.date | date :'HH_mm' }}h

 
{{log.patient_name}}

 

{{log.pills}}

 
 
 

 

Services Web Amazon

AWS est le fournisseur de services choisi pour déployer SmartPill System car il offre une large gamme de services au sein du même écosystème nous permettant d'opter pour une approche entièrement sans serveur. Cela permet à l'application de s'adapter aux besoins de l'utilisateur et de ne payer que ce qu'elle est utilisée.

Smartpill Architecture Cloud

Le système Smartpill utilise une architecture entièrement sans serveur utilisant Amazon Web Services. Cela permet à l'application d'évoluer vers le haut et vers le bas afin de s'adapter aux besoins de l'utilisateur. L'architecture est décrite dans le schéma ci-dessous :

Le distributeur Smartpill utilise une carte Microchip AVR-IoT avec des capacités WiFi pour communiquer avec l'écosystème AWS. AVR-IoT est connecté via AWS IoT Core par le protocole MQTT. Cela permet une connectivité bidirectionnelle entre l'écosystème Cloud et le matériel lui-même. Cette communication est utilisée pour envoyer le message de distribution au distributeur ainsi que les événements de confirmation du distributeur vers le cloud.

L'interface d'application Web développée à l'aide du framework Ionic Angular NodeJS est compilée et leurs fichiers statiques sont téléchargés sur le service de stockage AWS S3. Le backend de l'application Web est un service HTTT API Rest développé avec AWS API Gateway qui appelle les fonctions Lambda. Ces fonctions Lambda communiquent avec la base de données DynamoDB qui stocke la configuration des pilules et les journaux de prise.

AWS Event bridge est utilisé comme un planificateur afin de déclencher les événements de distribution au bon moment. Cet événement déclenche une fonction Lambda qui recherchera dans la base de données les pilules nécessaires à chaque prise et enverra ces informations au distributeur SmartPill au moyen de l'IoT Core.

AWS-IoT Noyau

La première chose que vous devez faire pour commencer à utiliser la carte AVR-IoT avec AWS IoT Core est de vous connecter à la carte à votre compte AWS. Ce processus est décrit par Microchip dans les guides du développeur IoT pour AWS

Avec cela, vous aurez votre carte AVR-IoT prête à être utilisée dans votre compte AWS. Vous pouvez le voir dans AWS IoT Core sous Gérer → Onglet Objets.

Assurez-vous ensuite que votre carte AVR-IoT a accès à Internet en la configurant avec vos informations d'identification WiFi comme décrit dans le Guide de démarrage :

AWS DynamoDB

Ensuite, vous voudrez configurer l'application Web, pour cela, la première chose que vous devez faire est d'enregistrer les tables DynamoDB dont l'application Web a besoin :

• smartpill-history :stockera tous les journaux des pilules prises
• smartpill-pills :stockera vos pilules configurées

Cliquez sur créer une table :

Donnez-lui le nom exact et sélectionnez "id" comme clé primaire.

AWS Lambda

Assurez-vous que AmazonDynamicDBFullAccess est connecté. Pour que la fonction Lambda puisse lire/écrire à partir de la base de données DynamoDB. Pour cela, rendez-vous dans l'onglet Autorisations :

Et cliquez sur Nom du rôle. Cela vous redirigera vers le rôle d'exécution pour cette fonction Lambda. Nous recommandons que chaque fonction Lambda ait son propre rôle d'exécution.

AmazonDynamoDBFullAccess doit apparaître, sinon cliquez sur Joindre les politiques et recherchez "dynamodb" :

Donner à la fonction Lambda un accès complet à DynamoDB n'est sûr que pour les besoins de ce didacticiel, et ne doit pas être fait pour un environnement de production.

Allez maintenant dans la configuration et ajoutez le code de la fonction depuis le référentiel Github (lien ci-dessous) :

Répétez cette opération pour toutes les fonctions Lambda sur le référentiel.

Ensuite, nous allons configurer les intégrations entre Lambda et IoT Core afin que la fonction appropriée soit exécutée lorsque le message est envoyé par la carte.

Nous allons configurer le message de confirmation de distribution envoyé par l'AVR-IoT afin que l'entrée de journal et la notification correspondantes puissent être générées sur la base de données.

Nous allons sur AWS-IoT Core, cliquez sur Ajouter et règles pour configurer une règle :

Cliquez sur Créer une nouvelle règle et donnez un nom :smartpill_confirmationpill et une brève description

Saisissez ensuite l'instruction de requête suivante :

SELECT * FROM 'confirmationpill' 

et configurez une action "Envoyer un message à une fonction Lambda" pour pointer vers la "smartpill-confirmationpill" précédemment créée :

Vous êtes prêt à passer à la partie suivante.

Pont d'événement AWS

Event Bridge se chargera de lancer la fonction lambda qui enverra le message au SmartPill Dispenser afin de distribuer la pilule au bon moment. Nous allons configurer 3 événements programmés de déclenchement pour ce faire. Un pour le matin, un pour l'après-midi et un pour les apports nocturnes.

Accédez au service AWS Event Bridge et cliquez sur "Créer une règle".

Donnez-lui un nom et configurez le modèle d'événement de planification en tant qu'expression cron :

REMARQUE :Tenez compte du fait que ces expressions cron sont en heure UTC.

Sélectionnez la fonction Lambda « smartpill-dispensepill » comme cible :

Cette fonction Lambda sera exécutée à l'heure définie.

Définissez deux règles supplémentaires pour l'heure souhaitée pour les apports du matin, de l'après-midi et du soir.

Passerelle API AWS

Accédez à AWS API Gateway et cliquez sur Créer une API. Choisissez l'API HTTP et cliquez sur Build :

Donnez-lui "smartpill-webui" comme nom (ou ce que vous voulez, cela n'a pas vraiment d'importance)

Et configurez toutes les fonctions Lambda en tant qu'intégrations :

Cliquez sur Suivant et configurez toutes les routes comme spécifié dans le tableau ci-dessous :

Enfin, déployez l'API pour obtenir un point de terminaison HTTP.

Vous pouvez également importer le fichier JSON 'smartpill-api.json' dans le référentiel ci-dessous.

AWS S3

Le service de stockage AWS S3 est conçu pour stocker des fichiers, mais il peut également servir de serveur Web statique, par exemple une page Web. Pour ce faire, vous devez d'abord créer un Bucket.

Allez sur S3 et cliquez sur « Créer un seau » :

Donnez un nom convivial (ce sera votre DNS).

Vous devrez maintenant activer la fonction d'hébergement de site Web statique. Allez dans les propriétés et allez directement en bas. Vous trouverez ceci :

Click on "Edit" and Enable the Static website hosting feature and select 'index.html' as your index and error document:

Then upload your website static files that Angular has compiled and access your DNS. You are ready to go!

AVR-IoT Board

AVR-IoT board from Microchip is used as a communication interface in order to provide connectivity to the Cloud to the Dispenser. It is connected to the Main Arduino Board by means of a Serial interface.

Firmware for the AVR-IoT WA Development Board based on the original example

The already implemented CLI have been extended including the command "pill" , its corresponding callback pill_command() that parses the message and sends th confirmation JSON by MQTT to the topic "confirmationpill". Also, the message in case of unknown message is customized as well as in the callback in case of incorrect parameter.

The original CLI used the USART2, which is connected to the debugger by the PCB but is not accessible. For this version, the CLI structure and the funtionality printf() are now implemented on the USART1, which is avaliable with the pin conectors RX and TX . This alows us to use this CLI with any external device, taking into account the following configuration:

We have also managed to add a custom MQTT topic subscription with a JSON parser. On the aplication_manager.c could be found the modified version of subscribeToCloud() to subscribe to "dispensepill" custom topic and how it is linked to a custom callback receiveddispenseFromCloud() in which the data from the JSON is extracted.

On IoTPill.h header are defined the main structures used to control the data received and sent.

In order to enable communication between the Main Arduino board and the AVR-IoT we have developed a simple communication bidirectional protocol that has two messages.

• dispensepill: Will be triggered by AWS Event Bridge at the right time and will send the event to the Dispenser to dispense a pill
• confirmationpill :Will be send by the AVR-IoT board when the pill has been correctly dispensed in order to announce it to the AWS, which will log into the database.

'dispensepill' message (AWS → IoT Board → Arduino)

Event Bridge will trigger the smartpill-dispensepill Lambda function to send by MQTT to IoT Board a JSON formated string that has this fields:

{
 "cmd":"dispensepill",
 "npills":2,
 "intake":{
 "time":"morning"
 },
 "pills":{
 "1":{
 "pill":"Ibuprofeno",
 "qty":1,
 "deposit":1,
 "weight":200
 },
 "2":{
 "pill":"Paracetamol",
 "qty":2,
 "deposit":2,
 "weight":500
 }
 }
} 

and the IoT board will send by USART to the Arduino:

D Ibuprofeno 1 1 200 D Paracetamol 2 2 500 \n 

'confirmationpill' messageArduino → IoT Board → AWS

The arduino will send to the command "pill " and, if the delivery was incorrect or correct, it will add a ' 1 ' if it was okay:

pill 1 

This message will be processed by the custom CLI of the IoT Board taking into account the intake previusly send ( specifying the corresponding "time") and it will send the following JSON to AWS:

{
 "time":"morning",
 "state":"ok"
} 

AWS will send the log with Lambda functions triggered to the Web service

Any questions? Leave a comment below and we will do our best to help you!

Code

Smartpill Web Application

Smartpill Backend Lambda functions

Smartpill AVR-IoT Code

Smartpill Arduino Code

Pièces et boîtiers personnalisés

Référentiel Thingiverse

Schémas