Slimme Pilverdeler: Precisie Medicatiebeheersysteem

Onderdelen en benodigdheden

Onderdeel	Aantal	Opmerking
Microchip Technology AVR-IoT WA Development Board	1
Arduino Mega 2560	1
SG90 Micro-servomotor	4
Itead Nextion NX8048T070 - 7.0" HMI TFT LCD Touch Display	1
Adafruit 16-kanaals 12-bit PWM/Servo Driver I2C	1
Luidspreker: 0.25W, 8 ohm	1
Adafruit Fototransistor IR-lichtsensor	4
Adafruit 5mm IR LED - 940nm	4
Ultrasonische sensor - HC-SR04 (Generiek)	1
Parallax Feedback 360° High-Speed Servo	1
Adafruit 5V 2A Schakelende wandvoeding	1

Benodigde tools en machines

• 3D-printer (generiek)
• Soldeerbout (generiek)
• Soldeerdraad, loodvrij

Apps en online diensten

• 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

Over dit project

Waarom dit project?

Op de markt zijn momenteel twee typen pilverdelers: niet-elektrische en automatische. Hoewel de meerderheid een herinneringsmechanisme heeft (niet altijd geschikt voor mensen met visuele of sensorische beperkingen), vereisen beide typen normaal gesproken een persoon die de pillen dagelijks of wekelijks in verschillende compartimenten organiseert, waardoor de patiënt afhankelijk is. Tegenwoordig, door Covid-19, hebben familieleden of mantelzorgers van ouderen meer moeite om zorg te geven aan afhankelijke personen.

Daarom zagen we de noodzaak om een slimme pilverdelers te maken die geen handmatige pilorganisatie nodig heeft, toegankelijk is voor gehandicapten en de patiënt meer onafhankelijkheid geeft.

Hieronder tonen we de 10 beste pilverdelers van 2020:

Zoals je ziet, is er nog veel te verbeteren in de wereld van pildozen. En dat is precies wat SmartPill gaat oplossen.

Hoe het werkt?

Het SmartPill-systeem bestaat uit 2 subsystemen:

• SmartPill Dispenser: Fysiek apparaat dat pillen organiseert, bewaart en uitlevert. Het fungeert als hoofdinterface voor de patiënt.
• SmartPill Web App: Web-gebruikersinterface die de arts of verantwoordelijke persoon voor de patiënt in staat stelt om de medicatie-inname te configureren en te volgen.

Met behulp van de webapplicatie met een vriendelijke gebruikersinterface kan de arts maximaal 4 verschillende pillen per SmartPill Dispenser configureren en maximaal 3 inname-momenten per dag per pil selecteren. Hierdoor kan de arts de dosering op afstand wijzigen wanneer nodig, zonder tussenkomst van de patiënt.

SmartPill is ontworpen met rekening houdende de moeilijkheden die een patiënt met seniele dementie, Alzheimer of visuele/gehoorbeperkingen kan hebben. De verdeler heeft een grootschermig display waarmee de patiënt de pillen comfortabel kan invullen, evenals geluids- en lichtfeedback die de patiënt op het juiste moment herinnert om de pillen te nemen.

De gebruiker hoeft zich geen zorgen te maken over waar of hoe de verschillende pillen moeten worden geplaatst. Er is een slim mechanisme dat de pillen binnenin de verdeler verdeelt en de benodigde dosis op het juiste moment uitlevert.

De SmartPill Dispenser heeft een draadloze internetverbinding met de AWS-cloud dankzij de WiFi-verbinding van het Microchip AVR-IoT-board, zodat het op afstand bewaakt en geconfigureerd kan worden via de webapplicatie.

De app toont ook wanneer de pillen zijn ingenomen en stuurt een notificatie naar het familieleden als de pil niet wordt ingenomen.

SmartPill Dispenser

Uitleversysteem

Je vraagt je misschien af: hoe werkt het uitleversysteem? Deze sectie toont alle verschillende onderdelen en legt hun functionaliteit uit.

We moeten duidelijk maken dat, behalve het scherm, alles 3D-geprint is met PLA-plastic. Je kunt ook het .STL-bestand van de gehele verdeler hieronder bekijken.

1. Basis: Ondersteunt de rest van de verdeler. Heeft twee gaten voor de bewegingsensor. Bevat een klep die de pillen in het bekertje brengt.

2. Schuif: De bovenkant van de schuif ondersteunt de pilhouder. Eronder zit een helling waar de pillen naar beneden rollen naar de klep. Aan de onderkant zit een gat voor de elektronica.

3. Zijdelen: Beschermen hardware en pillen tegen vocht, temperatuur, vuil en stof.

4. Nextion NX8048T070: Scherm gebruikt als interface tussen verdeler en gebruiker.

5. Bovenstukken:

• Beschermen hardware en pillen (boven).
• Scheiden de trommel van de pilhouders (onder).

6. Parallax Servo 900-0005: 360° elektrisch motor die onderdeel 7 in de juiste positie plaatst.

7. Trommel: Verbindingsbuis tussen buitenkant en pilhouders. Draait om de juiste houder te bereiken.

8. Achterdeur: Nodig om de pilhouders met de schuif in en uit te halen.

9. Luidsprekers: Communiceren alle benodigde informatie aan de gebruiker.

10. Ultrasonische Sensor - HC-SR04: Detecteert of het bekertje is weggehaald.

11. Pilhouders: Bevatten de pillen en leveren ze op het juiste moment met de juiste hoeveelheid uit. Als prototype hebben we 4 houwers ontworpen, maar het kan uitgebreid worden naar grotere capaciteit.

Wil je je eigen SmartPill Dispenser? Download de STL-bestanden onderaan en print alle onderdelen met je 3D-printer! Het project is volledig open-source.

In de volgende sectie leggen we stap voor stap uit hoe je het uitleversysteem monteert.

Montage

• Om de Schuif (Onderdeel 2 - Algehele tekening) te 3D-printen, hebben we het in drie delen opgesplitst. Eerst monteren we het. Pak de moeren (2.3.2 - Schuiftekening) en pas ze in de Schuif (2.2 - Schuiftekening) met een lasapparaat. Schroef daarna beide delen (2.3.1 & 2.2 - Schuiftekening). Wacht met de kap (2.4 - Schuiftekening) tot de elektronica is aangesloten.

• Plaats de elektronica in de gat van de schuif, inclusief de Ultrasonische Sensor - HC-SR04 (Onderdeel 10 - Algehele tekening) en schroef de schuifdeksel (2.4).
• Monteer de pilhouders (zie Pilhouder Tekening) met een SG90-servo elk. Voeg eerst Deel 1 met Deel 7 en schroef de SG90 aan Deel 7. Voeg daarna Deel 3 met Deel 4 (wieltje lager) en ten slotte Deel 2 toe. Schroef de pilhouders aan de bovenkant van de schuif (Deel 2 - Algehele tekening).

• Schroef het scherm (Deel 4 - Algehele tekening) aan de juiste zijkant en pas de stekker. Voeg daarna de zijkanten (Deel 3 - Algehele tekening) aan de basis tot ze klikken.
• Er zijn twee bovenstukken (Deel 5 - Algehele tekening). We monteren ze door weer de moeren te pakken en in de delen te passen. Deze keer is geen lasapparaat nodig. Plaats de Trommel (Deel 7 - Algehele tekening) en de Parallax Servo (Deel 6 - Algehele tekening) ertussen en schroef beide bovenstukken samen.
• Ten slotte schroef je de achterdeur (Deel 8 - Algehele tekening) aan de bovenste montage.

Elektronica

De hoofd-elektronische hersenen is een Arduino Mega die zorgt voor het besturen van de servomotoren die de pillen uitleveren, evenals het Nextion-touchscherm, de Real-Time Clock (RTC), geluidseffecten en het AVR-IoT-communicatiebord.

• AVR-IoT is verbonden met de Arduino Mega via een seriële UART-verbinding.
• Servomotoren worden bestuurd door PWM.
• RTC is verbonden met de Arduino Mega via I2C.
• IR-barrière-sensoren voor het detecteren van pillen zijn aangesloten op de analoge pinnen van de Arduino.

Om het project te repliceren, moet je alle verbindingen maken zoals beschreven in het schema met behulp van een steekbord of zelfgemaakte PCB. We raden ten zeerste aan de circuit op een houten plaat te monteren zoals op de foto hierboven.

Het schema vind je aan het einde van de pagina.

SmartPill Web App

De SmartPill Web App heeft als doel de ervaring van het instellen van een elektronisch apparaat en het beheren van andermans medicatie te vergemakkelijken.

• Eenvoudige opzet van de SmartPill Dispenser met patiëntgegevens, pillen die ingenomen moeten worden, benodigde dosering en tijdsintervallen.
• Monitoring van de pilinname.

Hoe is het ontwikkeld?

Om een webapplicatie vanaf nul te ontwikkelen, werk je met de fundamentele programmeergebieden: backend en frontend. De SmartPill WebApp is gemaakt met:

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

Ionic is een volledig gratis en open-source NodeJS-framework gebaseerd op AngularJS dat platform-specifieke UI-elementen biedt via een bibliotheek met native componenten voor iOS en Android. Het gebruikt front-end technologieën zoals HTML, CSS, JavaScript en Angular voor applicatieontwikkeling. Ionic kan Angular CLI (Command-Line Interface) gebruiken om volledig functionele mobiele applicaties te maken.

Let op: voordat je begint met Ionic, moet Node.js geïnstalleerd zijn, omdat Ionic deel uitmaakt van een groot JavaScript-ecosysteem.

De Ionic Framework Documentatie-pagina begeleidt je zonder problemen bij de start van je app. Ik zal kort de eerste stappen voor de creatie van de SmartPill-app noemen:

1. Ga naar de commandoregel van je code-editor en installeer Ionic CLI met npm:
   $ npm install -g @ionic/cli
2. Maak een nieuwe app:
   $ ionic start smartpill-webui blank
3. Ga naar de map van je frontend en run het:
   $ cd smartpill-webui
$ ionic serve

Het runnen van je app betekent dat je het kunt testen in de browser van je apparaat. Deze Ionic-functie is essentieel voor debugging en testen.

SmartPill Web App basisstructuur

De SmartPill Web App is simpel georganiseerd om navigatie te vereenvoudigen. In de app-mappen vind je het app-routing-module, de app-componentbestanden, een "services"-map en een map voor elke route.

Als je nog nooit frontend-technologieën hebt aangeraakt, zul je in het overzicht van deze code zien hoe de verschillende talen met elkaar interageren. Kort gezegd: het deel van de web dat je ziet is het HTML-bestand van de map, terwijl het TypeScript-bestand de functies zijn die draaien wanneer de gebruiker met de pagina interageert. De modules.ts zijn voor routing-doeleinden.

De meest essentiële bestanden van de SmartPill-app zijn:

• app-routing.module.ts. Staakt de gebruiker toe om door alle beschikbare routes te navigeren. Bepaalde paden laten de webontwikkelaar variabelen van de ene route naar de andere dragen.

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. Communiceert met de API. Hier worden de hoofdinterfaces gedefinieerd (Post, Dep en Log), samen met de klasse PostService. PostService heeft de basiscommunicatiefuncties met de API: get (om informatie op te halen), post (om een nieuw artikel aan te maken), delete (om een artikel te verwijderen) en put (om een bestaand artikel te bewerken, maar de vorige data te verwijderen).

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}`);
}
...

Configuratie- en bewerkpaginapil

SmartPill heeft een route om alle geprogrammeerde posts te tonen genaamd "page-config". Om een nieuwe post aan te maken voor de pilconfiguratie, drukt de gebruiker op een knop rechtsonder die hen leidt naar de bewerkpagina "page-edit-pill". Als ze niet willen maken maar bewerken, door te drukken op de bewerkknop van een bestaande post, leidt de web ook naar "page-edit-pill" maar meeneemt de id van de post. Deze twee statements zijn als volgt gedefinieerd:

• Nieuwe post knop aanmaken

<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>

• Bewerk post knop

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

De "page-edit-pill" herkent of de gebruiker de route met of zonder id is binnengekomen en voert de overeenkomstige functies uit met simpele if-statements.

• Pad met Id gedefinieerd in route module

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

• Uitlezen of de route een Id meedraagt

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

• If display voorbeeld

<ion-card-header>
 {{editing?
 'Update Your':
 'Create your'
 }} Deposit
</ion-card-header>

• If knop voorbeeld

<ion-button expand="full" (click)="editing? updatePost(): savePots()" class="ion-margin-top">
 {{editing ? 'Update' : 'Submit'}}
</ion-button>

De "edit-pill-page" interageert met de gebruiker via Ionic UI-componenten zoals inputs en selects, die later naar de API worden gestuurd:

• Tijd meervoudige selectie

<ion-item>
 <ion-label position="floating">Klik hier om tijdstip van de dag te kiezen.</ion-label>
 <ion-select [(ngModel)]="time" (ionChange)="onChange($event)" multiple="true"
   cancelText="Cancel" okText="Submit">
   <ion-select-option value="morning">Morgen</ion-select-option>
   <ion-select-option value="afternoon">Middag</ion-select-option>
   <ion-select-option value="night">Nacht</ion-select-option>
 </ion-select>
</ion-item>

• Pil invoer

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

De "config-page" is geprogrammeerd met Angular Life Cycle, zodat wanneer je terugkeert van "page-edit-pill" of een andere pagina, de pagina ververst wordt en de posts herladen, wijzigingen automatisch updaten.

• Load Post Functie

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)
 );
}

De "config-page" heeft ook een knop om elke pil te verwijderen. Het is een async-functie die een waarschuwingsbericht toont om te verifiëren of ze zeker weten.

• Een post verwijderen

async removePost(id: string){
 const alert= await this.alertController.create({
   header: "Alert",
   subHeader: "Weet je zeker dat je deze deposit wilt verwijderen?",
   message: "Je kunt het niet herstellen.",
   buttons: [
     "Cancel",
     {
       text: "Yes",
       handler: () => {
         this.postService.removePost(id).subscribe(
           (res) => {
             console.log(res);
             this.loadPosts();
           },
           (err) => console.log(err)
         );
       },
     },
   ],
 });
 await alert.present();
}

Logboekpagina

De logboekpagina haalt de informatie van de uitgeleverde pillen op en toont deze als log op de geschiedenisroute. Het werkt vergelijkbaar met "config-page" maar laadt alleen de informatie uit de API:

• Logs ophalen

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

ngOnInit() {
 this.loadPosts();
}

ionViewWillEnter(){
 this.loadPosts();
}

• Logs weergeven

<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 is gekozen als serviceprovider voor de implementatie van het SmartPill-systeem omdat het een breed scala aan diensten binnen hetzelfde ecosysteem biedt, wat ons in staat stelt een volledig serverloze aanpak te kiezen. Dit stelt de applicatie in staat om te schalen naar de behoeften van de gebruiker en alleen te betalen voor wat er gebruikt wordt.

SmartPill Cloud-architectuur

SmartPill gebruikt een volledig serverloze architectuur met Amazon Web Services. Dit stelt de applicatie in staat om op te schalen en af te schalen om aan de behoeften van de gebruiker te voldoen. De architectuur wordt beschreven in het diagram hieronder:

De SmartPill Dispenser gebruikt een Microchip AVR-IoT-board met WiFi-mogelijkheden om te communiceren met het AWS-ecosysteem. AVR-IoT is verbonden via AWS IoT Core met het MQTT-protocol. Dit stelt bidirectionele connectiviteit in tussen het cloudecosysteem en de hardware. Deze communicatie wordt gebruikt om het uitleverbericht naar de verdeler te sturen en bevestigingsgebeurtenissen van de verdeler naar de cloud.

De frontend van de webapplicatie, ontwikkeld met Ionic Angular NodeJS-framework, wordt gecompileerd en de statische bestanden worden geüpload naar AWS S3-opslagservice. De backend is een HTTP API REST-service ontwikkeld met AWS API Gateway die Lambda-functies aanroept. Deze Lambda-functies communiceren met de DynamoDB-database die de pilconfiguratie en inname-logs opslaat.

AWS Event Bridge wordt gebruikt als scheduler om de uitlevergebeurtenissen op het juiste moment te activeren. Deze gebeurtenis activeert een Lambda-functie die in de database zoekt naar de pillen die bij elke inname nodig zijn en stuurt deze informatie naar de SmartPill Dispenser via IoT Core.

AWS IoT Core

Het eerste wat je moet doen om het AVR-IoT-board met AWS IoT Core aan de slag te krijgen, is het verbinden van het board met je AWS-account. Dit proces wordt beschreven door Microchip in de IoT Developer Guides for AWS.

Hiermee is je AVR-IoT-board klaar in je AWS-account. Je kunt dit zien in AWS IoT Core onder het tabblad Manage → Things.

Zorg ervoor dat je AVR-IoT-board internettoegang heeft door het te configureren met je WiFi-referenties zoals beschreven in de Getting Started Guide.

AWS DynamoDB

Vervolgens wil je de webapplicatie configureren. Het eerste is het registreren van de DynamoDB-tabellen die de webapp nodig heeft:

• smartpill-history: slaat alle logs voor ingenomen pillen op
• smartpill-pills: slaat je geconfigureerde pillen op

Klik op "Create table":

Geef de exacte naam en selecteer "id" als primaire sleutel.

AWS Lambda

Zorg ervoor dat AmazonDynamoDBFullAccess is gekoppeld, zodat de Lambda-functie kan lezen/schrijven vanuit de DynamoDB-database. Ga hiervoor naar het tabblad Permissions:

Klik op de Role Name. Dit leidt je naar de Execution Role voor deze Lambda-functie. We raden aan dat elke Lambda-functie zijn eigen Execution Role heeft.

AmazonDynamoDBFullAccess moet verschijnen; zo niet, klik op "Attach policies" en zoek naar "dynamodb":

Volle DynamoDB-toegang geven aan de Lambda-functie is alleen veilig voor deze tutorial, niet voor productieomgevingen.

Ga nu naar Configuration en voeg de functiecode toe vanuit de GitHub-repository (link hieronder):

Herhaal dit voor alle Lambda-functies in de repository.

Vervolgens configureren we de integraties tussen Lambda en IoT Core zodat de juiste functie wordt uitgevoerd wanneer het bericht door het board wordt verzonden.

We configureren het bevestigingsbericht van de uitlevering dat door het AVR-IoT wordt verstuurd, zodat de bijbehorende log-entry en notificatie in de database kunnen worden gegenereerd.

Ga in AWS IoT Core naar "Add and Rules" om een regel te configureren:

Klik op "Create new Rule", geef een naam: smartpill_confirmationpill en een korte beschrijving.

Voer vervolgens de volgende query-instructie in:

SELECT * FROM 'confirmationpill'

En configureer een actie "Send a message to a Lambda function" die wijst naar de eerder aangemaakte smartpill-confirmationpill:

Je bent klaar voor het volgende deel.

AWS Event Bridge

Event Bridge zorgt ervoor dat de Lambda-functie die het bericht naar de SmartPill Dispenser stuurt om de pil uit te leveren, op het juiste moment wordt gelanceerd. We configureren 3 geplande trigger-gebeurtenissen: een voor de ochtend, een voor de middag en een voor de avond.

Ga naar AWS Event Bridge-service en klik op "Create a Rule".

Geef een naam en configureer het Schedule event pattern als een cron-expressie:

LET OP: Deze cron-expressies zijn in UTC-tijd.

Selecteer de smartpill-dispensepill Lambda-functie als Target:

Deze Lambda-functie wordt uitgevoerd op het gedefinieerde tijdstip.

Definieer twee extra regels voor de gewenste tijden van ochtend-, middag- en avondinname.

AWS API Gateway

Ga naar AWS API Gateway en klik op "Create API". Kies HTTP API en klik op Build:

Geef "smartpill-webui" als naam (of wat je wilt, dit maakt niet echt uit).

Configureer alle Lambda-functies als Integraties:

Klik Next en configureer alle routes zoals gespecificeerd in de onderstaande tabel:

Ten slotte, deploy de API om een HTTP-endpoint te krijgen.

Alternatief kun je het JSON-bestand 'smartpill-api.json' uit de repository importeren.

AWS S3

AWS S3-opslagservice is bedoeld voor het opslaan van bestanden, maar kan ook fungeren als statische webserver voor bijvoorbeeld een webpagina. Om dit te doen, moet je eerst een Bucket aanmaken.

Ga naar S3 en klik op "Create a Bucket":

Geef een vriendelijke naam (dit wordt je DNS).

Nu moet je de Static website hosting-functie activeren. Ga naar Properties en scroll helemaal naar beneden. Je vindt dit:

Klik op "Edit" en schakel Static website hosting in en selecteer 'index.html' als index- en foutdocument:

Upload nu de statische websitebestanden die Angular heeft gecompileerd en open je DNS. Je bent klaar!

AVR-IoT Board

Het AVR-IoT-board van Microchip wordt gebruikt als communicatie-interface om connectiviteit met de cloud aan de verdeler te bieden. Het is verbonden met de hoofd-Arduino-board via een seriële interface.

Firmware voor het AVR-IoT WA Development Board gebaseerd op het oorspronkelijke voorbeeld.

De al geïmplementeerde CLI is uitgebreid met het commando "pill", de bijbehorende callback pill_command() die het bericht parst en de bevestigings-JSON via MQTT naar het topic "confirmationpill" stuurt. Ook het bericht bij onbekend commando is aangepast, evenals de callback bij onjuiste parameter.

De oorspronkelijke CLI gebruikte USART2, wat verbonden is met de debugger via de PCB maar niet toegankelijk is. Voor deze versie zijn de CLI-structuur en de functionaliteit printf() geïmplementeerd op USART1, wat beschikbaar is met de pin-connectors RX en TX. Hierdoor kunnen we deze CLI met elk extern apparaat gebruiken, rekening houdend met de volgende configuratie:

We hebben ook een aangepaste MQTT-topic-abonnement met een JSON-parser weten toe te voegen. In application_manager.c vind je de gewijzigde versie van subscribeToCloud() om in te schrijven op het aangepaste topic "dispensepill" en hoe het gekoppeld is aan een aangepaste callback receiveddispenseFromCloud() waarin de data uit de JSON wordt geëxtraheerd.

In IoTPill.h header zijn de belangrijkste structuren gedefinieerd die gebruikt worden om de ontvangen en verzonden data te controleren.

Om communicatie tussen de hoofd-Arduino-board en het AVR-IoT te mogelijk te maken, hebben we een eenvoudig bidirectioneel communicatieprotocol ontwikkeld met twee berichten:

• dispensepill: Wordt getriggerd door AWS Event Bridge op het juiste moment en stuurt het evenement naar de verdeler om een pil uit te leveren.
• confirmationpill: Wordt verstuurd door het AVR-IoT-board wanneer de pil correct is uitgeleverd, om dit aan AWS te melden, wat het in de database logt.

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

Event Bridge activeert de smartpill-dispensepill Lambda-functie om via MQTT naar het IoT-board een JSON-geformatteerde string te sturen met deze velden:

{
 "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
   }
 }
}

Het IoT-board stuurt via USART naar de Arduino:

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

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

De Arduino stuurt het commando "pill " en, als de levering correct of incorrect was, voegt het een ' 1 ' toe als het ok was:

pill 1

Dit bericht wordt verwerkt door de aangepaste CLI van het IoT-board, rekening houdend met de inname die eerder is verstuurd (met het bijbehorende "time") en stuurt de volgende JSON naar AWS:

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

AWS stuurt de log met Lambda-functies getriggerd naar de webservice.

Vragen? Laat een reactie achter en we helpen je graag!

Code

SmartPill Webapplicatie

Frontend-code voor de webapp-gebruikersinterface:
https://github.com/makers-upv/smartpill-webui

SmartPill Backend Lambda-functies

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

SmartPill AVR-IoT Code

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

SmartPill Arduino Code

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

Aangepaste onderdelen en behuizingen

Thingiverse Repository

Thingiverse-repository voor SmartPill Dispenser CAD-bestanden op thingiverse.com
Pilverdelingsmechanisme dat de juiste hoeveelheid pillen uitlevert. Wordt bestuurd door een servo.
SmartPill Dispenser behuizing
De volledige samenstelling van het project. In STEP-formaat zodat iedereen het kan aanpassen.
smartpill_full_assembly_ybV7DD7ehX.step

Schema's

SmartPill Elektronica HW-aansluitingen