Distributeur de Pilules Intelligent : Système de Gestion de Médicaments de Précision

Composants et fournitures

Composant	Quantité
Carte de développement Microchip AVR-IoT WA	1
Arduino Mega 2560	1
Micro-servomoteur SG90	4
Écran tactile TFT HMI Nextion NX8048T070 7.0"	1
Pilote PWM/Servo 16 canaux 12-bit I2C Adafruit	1
Haut-parleur 0.25W, 8 ohms	1
Capteur IR Photo-transistor Adafruit	4
LED IR 5mm 940nm Adafruit	4
Capteur ultrasonique HC-SR04 (générique)	1
Servo à retour 360° haute vitesse Parallax	1
Alimentation murale 5V 2A Adafruit	1

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
• Amazon Web Services AWS API Gateway
• Amazon Web Services AWS Lambda
• Microsoft VS Code

À propos de ce projet

Pourquoi ce projet ?

Actuellement, il existe sur le marché deux types de distributeurs de pilules : non-électriques et automatiques. Bien que la plupart disposent d'un mécanisme de rappel (pas toujours adapté aux personnes malvoyantes ou ayant des troubles sensoriels), les deux types nécessitent normalement qu'une personne organise les pilules quotidiennement ou hebdomadairement dans différents compartiments, rendant le patient dépendant. Aujourd'hui, en raison du Covid-19, les proches ou assistants des personnes âgées ont plus de difficultés à prendre soin des personnes dépendantes.

C'est pourquoi nous avons vu la nécessité de créer un distributeur de pilules intelligent qui :

• Ne nécessite pas d'organisation manuelle des pilules
• Est accessible aux personnes handicapées
• Permet aux patients d'être plus autonomes

Voici ci-dessous les 10 meilleurs distributeurs de pilules de 2020 :

(L'article original mentionnait une liste mais ne l'incluait pas dans le contenu fourni)

Comme vous pouvez le constater, il reste beaucoup à améliorer dans le monde des piluliers. C'est exactement ce que SmartPill va résoudre.

Comment ça marche ?

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

• SmartPill Dispenser : Dispositif physique qui organise, stocke et distribue les pilules. Il agit comme interface principale pour le patient.
• SmartPill Web App : Interface web permettant au médecin ou au responsable du patient de configurer et suivre les prises de médicaments.

Grâce à l'application web avec une interface conviviale, le médecin peut configurer jusqu'à 4 pilules différentes par distributeur et sélectionner jusqu'à 3 prises par jour pour chaque pilule. Cela permet au médecin de modifier le dosage à distance quand nécessaire, sans intervention du patient.

Le système SmartPill a été conçu en tenant compte des difficultés des patients atteints de démence sénile, d'Alzheimer, ou de déficiences visuelles/auditives. Le distributeur dispose d'un grand écran pour faciliter le remplissage, ainsi que d'un retour sonore et lumineux pour rappeler la prise au bon moment.

L'utilisateur n'a pas à se soucier de l'emplacement des pilules : un mécanisme intelligent les répartit dans le distributeur et délivre la dose exacte au moment voulu.

Le SmartPill Dispenser dispose d'une connexion Internet sans fil vers le Cloud AWS grâce au WiFi de la carte Microchip AVR-IoT, permettant une surveillance et une configuration à distance via l'application web.

L'application affiche aussi quand les pilules ont été prises et notifie le proche si une pilule n'a pas été prise.

SmartPill Dispenser

Système de distribution

Vous vous demandez comment fonctionne le système de distribution ? Cette section détaille toutes les pièces et leur fonctionnalité.

Précisons que hormis l'écran, tout a été imprimé en 3D avec du PLA. Vous pouvez aussi consulter le fichier .STL complet du distributeur en bas de page.

1. Base : Supporte l'ensemble. Deux trous pour le capteur de mouvement. Contient un clapet qui amène les pilules dans le gobelet.

2. Curseur (Slider) : Le dessus supporte les contenants à pilules. En dessous, une pente guide les pilules vers le clapet. En bas, un espace pour l'électronique.

3. Pièces latérales : Protègent le matériel et les pilules de l'humidité, température, saleté et poussière.

4. Écran Nextion NX8048T070 : Interface entre le distributeur et l'utilisateur.

5. Pièces supérieures :

• Protection du matériel et des pilules (partie haute)
• Séparation du tambour et des contenants (partie basse)

6. Servo Parallax 900-0005 : Moteur électrique 360° qui positionne la pièce n°7.

7. Tambour (Drum) : Tube de connexion entre l'extérieur et les contenants. Tourne pour atteindre le bon contenant.

8. Porte arrière : Permet d'insérer/retirer les contenants avec le curseur.

9. Haut-parleurs : Communiquent toutes les informations nécessaires à l'utilisateur.

10. Capteur ultrasonique HC-SR04 : Détecte si le gobelet a été éloigné.

11. Contenants à pilules : Contiennent les pilules et les distribuent au bon moment avec la bonne quantité. Le prototype comporte 4 contenants, mais peut être adapté à une plus grande capacité.

Vous voulez votre propre SmartPill Dispenser ? Téléchargez les fichiers STL en bas de page et imprimez toutes les pièces avec votre imprimante 3D ! Le projet est entièrement open-source.

La section suivante explique pas à pas l'assemblage du système de distribution.

Assemblage

• Pour imprimer le Curseur (Pièce 2 - Vue d'ensemble), nous l'avons divisé en trois parties. Assemblez-le d'abord : insérez les écrous (2.3.2 - Plan du Curseur) dans le Curseur (2.2 - Plan du Curseur) avec un fer à souder. Vissez les deux parties (2.3.1 & 2.2 - Plan du Curseur). N'installez le couvercle (2.4 - Plan du Curseur) qu'après le câblage électronique.

• Placez l'électronique dans l'espace du curseur, y compris le capteur ultrasonique HC-SR04 (Pièce 10 - Vue d'ensemble) et vissez le couvercle du curseur (2.4).
• Assemblez les contenants à pilules (voir Plan des Contenants) avec un servomoteur SG90 chacun. Assemblez d'abord la Partie 1 avec la Partie 7 et vissez le SG90 sur la Partie 7. Assemblez ensuite la Partie 3 avec la Partie 4 (roulement) et ajoutez enfin la Partie 2. Vissez les contenants sur le dessus du curseur (Partie 2 - Vue d'ensemble).

• Vissez l'écran (Pièce 4 - Vue d'ensemble) sur la pièce latérale appropriée et branchez la prise. Assemblez ensuite les pièces latérales (Pièce 3 - Vue d'ensemble) à la base jusqu'à encliquetage.
• Il y a deux pièces supérieures (Pièce 5 - Vue d'ensemble). Assemblez-les en insérant à nouveau les écrous dans les pièces (pas de fer à souder nécessaire cette fois). Placez le Tambour (Pièce 7 - Vue d'ensemble) et le Servo Parallax (Pièce 6 - Vue d'ensemble) entre elles et vissez les deux pièces supérieures ensemble.
• Enfin, vissez la porte arrière (Pièce 8 - Vue d'ensemble) sur l'assemblage de la pièce supérieure.

Électronique

Le cerveau électronique principal est un Arduino Mega qui gère : le contrôle des servomoteurs de distribution, l'écran tactile Nextion, l'horloge temps réel (RTC), les effets sonores et la carte de communication AVR-IoT.

• L'AVR-IoT est connecté à l'Arduino Mega via une liaison série UART.
• Les servomoteurs sont commandés par PWM.
• Le RTC est connecté à l'Arduino Mega par I2C.
• Les capteurs à barrière IR pour la détection des pilules sont connectés aux entrées analogiques de l'Arduino.

Pour reproduire le projet, effectuez toutes les connexions comme décrit dans le schéma avec une plaque d'essai ou un PCB maison. Nous recommandons vivement de monter le circuit sur une plaque en bois comme sur la photo ci-dessus.

Le schéma est disponible en bas de page.

SmartPill Web App

L'application web SmartPill vise à simplifier la configuration d'un dispositif électronique et le suivi de la médication d'un tiers.

• Configuration facile du SmartPill Dispenser : informations du patient, pilules à prendre, dosage, créneaux horaires.
• Suivi des prises de pilules.

Comment a-t-elle été développée ?

Pour développer une application web de zéro, on travaille sur les deux piliers de la programmation : backend et frontend. La SmartPill WebApp a été créée avec :

• Backend. AWS API Gateway (API REST HTTP).
• Frontend. Ionic & Angular.

Ionic est un framework NodeJS gratuit et open-source basé sur AngularJS, qui fournit des éléments d'interface spécifiques à chaque plateforme via une bibliothèque de composants natifs pour iOS et Android. Il utilise les technologies front-end : HTML, CSS, JavaScript et Angular. Ionic peut utiliser Angular CLI pour créer des applications mobiles pleinement fonctionnelles.

Notez que Node.js doit être installé avant de démarrer avec Ionic, car Ionic fait partie d'un vaste écosystème JavaScript.

La documentation Ionic Framework vous guidera sans problème dans le démarrage de votre app. Voici brièvement les premières étapes suivies pour la création de l'app SmartPill :

1. Dans la ligne de commande de votre éditeur de code, installez Ionic CLI avec npm :

$ npm install -g @ionic/cli

2. Créez une nouvelle app :

$ ionic start smartpill-webui blank

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

$ cd smartpill-webui
$ ionic serve

Lancer votre app signifie que vous pouvez la tester dans le navigateur de votre appareil. Cette fonction Ionic est essentielle pour le débogage et les tests.

Structure de base de la SmartPill Web App

L'application est organisée simplement pour faciliter la navigation. Dans les dossiers de l'app, on trouve : le module de routage, les fichiers de composants, un dossier « services » et un dossier par route.

Si vous n'avez jamais touché au frontend, vous remarquerez dans l'aperçu du code comment les différents langages interagissent. En résumé : la partie visible est le fichier HTML du dossier, le fichier TypeScript contient les fonctions exécutées lors des interactions utilisateur, et les modules.ts gèrent le routage.

Les fichiers les plus essentiels :

• app-routing.module.ts. Permet la navigation entre toutes les routes. Certains chemins permettent de transmettre des variables d'une route à l'autre.

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

• post.service.ts. Communique avec l'API. Définit les interfaces principales (Post, Dep, Log) et la classe PostService avec les fonctions de base : get (récupérer), post (créer), delete (supprimer), put (modifier en remplaçant les données).

getPosts() { return this.http.get<Post[]>(this.API); }
getDeposit() { return this.http.get<Dep[]>(this.DEPOSIT); }
getLogs() { return this.http.get<Log[]>(this.LOGS); }

createPost(pill: string, deposit: string, weight: string, morning: boolean, afternoon: boolean, night: boolean) {
  return this.http.post<Post[]>(this.API, { pill, deposit, weight, morning, afternoon, night });
}

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

Page de configuration et d'édition des pilules

SmartPill a une route dédiée à l'affichage de tous les posts programmés : « page-config ». Pour créer un nouveau post, l'utilisateur appuie sur le bouton en bas à droite qui le redirige vers « page-edit-pill ». S'il veut modifier un post existant, en appuyant sur le bouton d'édition, il est aussi redirigé vers « page-edit-pill » mais avec l'id du post. Ces deux comportements sont définis ainsi :

• Bouton « Créer un nouveau post »

<ion-fab routerLink="/page-edit-pill" vertical="bottom" horizontal="end" slot="fixed">
  <ion-fab-button>
    <ion-icon name="add"></ion-icon>
  </ion-fab-button>
</ion-fab>

• Bouton « Modifier le post »

<ion-button [routerLink]="['/','pill','edit', post.id]" shape="round">
  <ion-icon slot="start" name="create"></ion-icon>
  Modifier
</ion-button>

La page « page-edit-pill » détecte si l'utilisateur est arrivé avec ou sans id, et exécute les fonctions correspondantes grâce à de simples conditions.

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

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

• Lecture de l'Id dans la route

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

• Exemple d'affichage conditionnel

<ion-card-header>
  {{ editing ? 'Mettre à jour votre' : 'Créer votre' }} Dépôt
</ion-card-header>

• Exemple de bouton conditionnel

<ion-button expand="full" (click)="editing ? updatePost() : savePost()" class="ion-margin-top">
  {{ editing ? 'Mettre à jour' : 'Soumettre' }}
</ion-button>

La page « edit-pill-page » interagit avec l'utilisateur via des composants UI Ionic (inputs, selects) qui seront envoyés à l'API :

• Sélection multiple des horaires

<ion-item>
  <ion-label position="floating">Cliquez pour choisir l'heure de la journée.</ion-label>
  <ion-select [(ngModel)]="time" (ionChange)="onChange($event)" multiple="true" cancelText="Annuler" okText="Valider">
    <ion-select-option value="morning">Matin</ion-select-option>
    <ion-select-option value="afternoon">Après-midi</ion-select-option>
    <ion-select-option value="night">Soir</ion-select-option>
  </ion-select>
</ion-item>

• Saisie du nom de la pilule

<ion-item>
  <ion-label position="floating">Nom de la pilule : </ion-label>
  <ion-input [(ngModel)]="post.pill"></ion-input>
</ion-item>

La « config-page » utilise le cycle de vie Angular : quand on revient de « page-edit-pill » ou d'une autre page, elle se rafraîchit et recharge les posts, mettant à jour les changements automatiquement.

• Fonction de chargement des posts

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 « config-page » a aussi un bouton pour supprimer une pilule. C'est une fonction asynchrone qui affiche une alerte de confirmation.

• Suppression d'un post

async removePost(id: string) {
  const alert = await this.alertController.create({
    header: 'Alerte',
    subHeader: 'Êtes-vous sûr de vouloir supprimer ce dépôt ?',
    message: 'Vous ne pourrez pas le récupérer.',
    buttons: [
      'Annuler',
      {
        text: 'Oui',
        handler: () => {
          this.postService.removePost(id).subscribe((res) => { console.log(res); this.loadPosts(); }, (err) => console.log(err));
        }
      }
    ]
  });
  await alert.present();
}

Page des logs

La page des logs récupère les informations sur les pilules distribuées et les affiche sous forme d'historique. Elle fonctionne comme la « config-page » mais ne charge que les données de l'API :

• Récupération des logs

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 logs

<ion-content>
<ion-list>
  <ion-item *ngFor="let log of log">
    <ion-item>
      <ion-icon *ngIf="log.time == 'morning'" name="sunny" slot="start"></ion-icon>
      <ion-icon *ngIf="log.time == 'afternoon'" name="pizza" slot="start"></ion-icon>
      <ion-icon *ngIf="log.time == 'night'" name="moon" slot="start"></ion-icon>
      <ion-label>
        <h4>{{ log.date | date: 'dd/MM/yyy' }} - {{ log.date | date: 'HH_mm' }}h</h4>
        <h3>{{log.patient_name}}</h3>
        <p>{{log.pills}}</p>
      </ion-label>
    </ion-item>
  </ion-item>
</ion-list>
</ion-content>

Amazon Web Services

AWS a été choisi pour déployer le système SmartPill car il offre une large gamme de services dans un même écosystème, permettant une approche complètement serverless. Cela permet à l'application de s'adapter aux besoins de l'utilisateur et de ne payer que ce qui est consommé.

Architecture Cloud SmartPill

Le système utilise une architecture entièrement serverless sur AWS. Le diagramme ci-dessous la décrit :

Le SmartPill Dispenser utilise une carte Microchip AVR-IoT avec WiFi pour communiquer avec l'écosystème AWS. L'AVR-IoT se connecte via AWS IoT Core par protocole MQTT, permettant une connectivité bidirectionnelle entre le Cloud et le matériel. Cette communication sert à envoyer le message de distribution au distributeur et les événements de confirmation du distributeur vers le Cloud.

Le frontend de l'application web (Ionic Angular NodeJS) est compilé et ses fichiers statiques sont hébergés sur AWS S3. Le backend est une API REST HTTP développée avec AWS API Gateway qui appelle des fonctions Lambda. Ces fonctions communiquent avec la base de données DynamoDB qui stocke la configuration des pilules et les logs de prise.

AWS EventBridge agit comme planificateur pour déclencher les événements de distribution au bon moment. Cet événement déclenche une fonction Lambda qui recherche en base les pilules nécessaires pour chaque prise et envoie l'information au SmartPill Dispenser via IoT Core.

AWS IoT Core

La première étape pour faire fonctionner la carte AVR-IoT avec AWS IoT Core est de la connecter à votre compte AWS. Ce processus est décrit par Microchip dans les IoT Developer Guides for AWS.

Une fois fait, votre carte AVR-IoT apparaît dans AWS IoT Core sous l'onglet Gérer → Objets (Things).

Assurez-vous que votre carte AVR-IoT a accès à Internet en la configurant avec vos identifiants WiFi comme décrit dans le Getting Started Guide.

AWS DynamoDB

Ensuite, configurez l'application web en créant les tables DynamoDB nécessaires :

• smartpill-history : Stocke tous les logs de prises de pilules
• smartpill-pills : Stocke vos pilules configurées

Cliquez sur « Créer une table », donnez le nom exact et sélectionnez « id » comme clé primaire.

AWS Lambda

Assurez-vous que la politique AmazonDynamoDBFullAccess est attachée au rôle d'exécution de la fonction Lambda pour qu'elle puisse lire/écrire dans DynamoDB. Allez dans l'onglet Permissions :

Cliquez sur le nom du rôle. Cela vous redirige vers le rôle d'exécution. Nous recommandons un rôle d'exécution par fonction Lambda.

AmazonDynamoDBFullAccess doit apparaître. Sinon, cliquez sur « Attacher des politiques » et recherchez « dynamodb » :

Donner un accès complet DynamoDB à la fonction Lambda n'est sûr que pour ce tutoriel, pas pour un environnement de production.

Allez dans Configuration et ajoutez le code de la fonction depuis le dépôt GitHub (lien ci-dessous) :

Répétez pour toutes les fonctions Lambda du dépôt.

Ensuite, configurez les intégrations entre Lambda et IoT Core pour que la bonne fonction s'exécute quand le message est envoyé par la carte.

Configurez la confirmation de distribution envoyée par l'AVR-IoT pour générer l'entrée de log et la notification correspondantes en base.

Allez dans AWS IoT Core, cliquez sur Ajouter → Règles pour configurer une règle :

Créez une nouvelle règle nommée smartpill_confirmationpill avec une brève description.

Entrez la déclaration de requête suivante :

SELECT * FROM 'confirmationpill'

Et configurez une action « Envoyer un message à une fonction Lambda » pointant vers smartpill-confirmationpill créée précédemment :

AWS EventBridge

EventBridge se charge de lancer la fonction Lambda qui enverra le message au SmartPill Dispenser pour distribuer la pilule au bon moment. Nous configurons 3 événements planifiés : un pour le matin, un pour l'après-midi, un pour le soir.

Allez dans le service AWS EventBridge et cliquez sur « Créer une règle ». Donnez-lui un nom et configurez le motif d'événement planifié comme une expression cron :

NOTE : Ces expressions cron sont en heure UTC.

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

Cette fonction Lambda s'exécutera à l'heure définie. Définissez deux autres règles pour les heures souhaitées (matin, après-midi, soir).

AWS API Gateway

Allez dans AWS API Gateway et cliquez sur « Créer une API ». Choisissez « API HTTP » et cliquez sur « Construire » :

Donnez-lui le nom « smartpill-webui » (ou ce que vous voulez). Configurez toutes les fonctions Lambda comme 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. Alternativement, vous pouvez importer le fichier JSON smartpill-api.json du dépôt.

AWS S3

AWS S3 sert à stocker des fichiers mais peut aussi agir comme serveur web statique (ex: page web). Pour ce faire, créez d'abord un Bucket.

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

Donnez un nom convivial (ce sera votre DNS).

Activez l'hébergement de site web statique. Allez dans Propriétés, tout en bas :

Cliquez sur « Modifier », activez la fonctionnalité et sélectionnez index.html comme document d'index et d'erreur :

Uploadez les fichiers statiques de votre site compilés par Angular et accédez à votre DNS. C'est prêt !

Carte AVR-IoT

La carte AVR-IoT de Microchip sert d'interface de communication pour fournir la connectivité Cloud au distributeur. Elle est connectée à la carte Arduino principale par une interface série.

Firmware pour la carte AVR-IoT WA Development Board basé sur l'exemple original

Le CLI déjà implémenté a été étendu avec la commande « pill », son callback pill_command() qui parse le message et envoie la confirmation JSON par MQTT sur le topic « confirmationpill ». Le message en cas de commande inconnue est personnalisé, tout comme le callback en cas de paramètre incorrect.

Le CLI original utilisait l'USART2, connecté au débogueur par le PCB mais non accessible. Pour cette version, la structure CLI et la fonctionnalité printf() sont maintenant implémentées sur l'USART1, disponible sur les connecteurs RX et TX. Cela permet d'utiliser ce CLI avec n'importe quel dispositif externe, avec la configuration suivante :

Nous avons aussi ajouté une souscription MQTT personnalisée avec un parseur JSON. Dans application_manager.c se trouve la version modifiée de subscribeToCloud() pour s'abonner au topic personnalisé « dispensepill » et comment elle est liée à un callback personnalisé receiveddispenseFromCloud() qui extrait les données du JSON.

Dans l'en-tête IoTPill.h sont définies les principales structures pour contrôler les données reçues et envoyées.

Pour permettre la communication entre la carte Arduino principale et l'AVR-IoT, nous avons développé un protocole de communication bidirectionnel simple avec deux messages :

• dispensepill : Déclenché par AWS EventBridge au bon moment, envoie l'événement au distributeur pour distribuer une pilule
• confirmationpill : Envoyé par la carte AVR-IoT quand la pilule a été correctement distribuée, pour l'annoncer à AWS qui l'enregistrera en base

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

EventBridge déclenchera la fonction Lambda smartpill-dispensepill pour envoyer par MQTT à la carte IoT une chaîne JSON formatée avec ces champs :

{
  "cmd": "dispensepill",
  "npills": 2,
  "intake": { "time": "morning" },
  "pills": {
    "1": { "pill": "Ibuprofène", "qty": 1, "deposit": 1, "weight": 200 },
    "2": { "pill": "Paracétamol", "qty": 2, "deposit": 2, "weight": 500 }
  }
}

La carte IoT enverra par USART à l'Arduino :

D Ibuprofène 1 1 200 D Paracétamol 2 2 500 \n

Message 'confirmationpill' (Arduino → IoT Board → AWS)

L'Arduino enverra la commande « pill » et, si la distribution était correcte, ajoutera un « 1 » :

pill 1

Ce message sera traité par le CLI personnalisé de la carte IoT en tenant compte de la prise précédemment envoyée (spécifiant le « time » correspondant) et enverra le JSON suivant à AWS :

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

AWS enverra le log via les fonctions Lambda déclenchées vers le service web.

Des questions ? Laissez un commentaire ci-dessous et nous ferons de notre mieux pour vous aider !

Code

Application Web SmartPill

Code frontend pour l'interface utilisateur de l'application web :

https://github.com/makers-upv/smartpill-webui

Fonctions Lambda Backend SmartPill

https://github.com/makers-upv/smartpill-lambda

Code AVR-IoT SmartPill

https://github.com/makers-upv/smartpill-avriot

Code Arduino SmartPill

https://github.com/makers-upv/smartpill-arduinofw

Pièces personnalisées et boîtiers

Dépôt Thingiverse

Dépôt Thingiverse pour le SmartPill Dispenser :

CAD file on thingiverse.com

• Mécanisme de distribution de pilules qui gère la distribution de la quantité correcte. Contrôlé par un servo.
• Boîtier du SmartPill Dispenser
• Assemblage complet du projet. Format STEP pour modification par tous. smartpill_full_assembly_ybV7DD7ehX.step

Schémas

Connexions matérielles électroniques SmartPill