Distribuidor inteligente de pílulas

Ferramentas e máquinas necessárias

	Impressora 3D (genérica)
	Ferro de soldar (genérico)
	Arame de solda, sem chumbo

Aplicativos e serviços online

	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
	Código Microsoft VS

Sobre este projeto

Por que este projeto?

Como funciona?

• Distribuidor Smartpill: Dispositivo físico que irá organizar, armazenar e dispensar os comprimidos. Ele atuará como a interface principal para o paciente.
• Smartpill Web App: Interface de usuário da web que permitirá ao médico ou pessoa responsável pelo paciente configurar e rastrear as entradas do paciente.

Dispensador SmartPill

• Usado para proteger o hardware e os comprimidos de umidade, temperaturas, sujeira e poeira (parte superior).
• Separa o tambor dos recipientes de pílulas (parte inferior).

• Para imprimir em 3D o Slider (Parte 2 - Desenho geral) nós o dividimos em três partes. Então, antes de mais nada, nós o montamos. Escolha as nozes ( 2.3.2 - Desenho deslizante ) e encaixá-los no Slider ( 2.2 - Desenho deslizante ) com um soldador. Em seguida, aparafuse ambas as partes ( 2.3.1 e 2.2 - Desenho deslizante ) Espere para colocar o limite (2.4 - Desenho do controle deslizante) até que o eletrônico esteja conectado.

• Coloque os componentes eletrônicos dentro da lacuna do controle deslizante, incluindo o Sensor Ultrassônico - HC SR4 (Parte 10 - Desenho Geral) e aparafuse a tampa do controle deslizante (2.4).
• Monte os recipientes para pílulas (veja o Desenho dos recipientes para pílulas ) com um servo SG90 cada. Primeiro junte a Parte 1 com a Parte 7 e aparafuse o SG90 à Parte 7 . Em seguida, junte a Parte 3 com a Parte 4 (rolamento da roda) e, finalmente, adicione a Parte 2. Em seguida, aparafuse os recipientes de pílulas no topo do Slider (Parte 2 - Desenho geral) .

• Dane-se a tela (Parte 4 - Desenho geral). na parte lateral adequada e encaixe o plugue. E, em seguida, encaixe as peças do Sider (Parte 3 - Desenho geral) para a base até clicarem.
• Existem duas partes principais ( (Parte 5 - Desenho geral) . Nós os montamos pegando novamente as porcas e encaixando-as nas peças. Desta vez, nenhum soldador é necessário. Encaixe o Tambor (Parte 7 - Desenho geral) e o Parallax Servo (Parte 6- Desenho geral) entre eles e aparafusamos as duas partes superiores.
• Finalmente aparafuse a porta traseira (Parte 8 - Desenho geral) para a montagem da parte superior.

• AVR-IoT é conectado ao Arduino Mega por meio de uma conexão UART serial.
• Servo motores são controlados por PWM.
• RTC está conectado ao Arduino Mega por I2C.
• O sensor de barreira IR para detectar os comprimidos está conectado aos pinos analógicos da placa Arduino.

SmartPill Web App

• Um dispensador SmartPill fácil de configurar, com as informações do paciente, os comprimidos que devem ser tomados, a dosagem necessária e o intervalo de tempo.
• Monitoramento da ingestão de comprimidos.

• Back-end. AWS API Gateway (HTTT API Rest).
• Frontend. Iônico e angular. Para desenvolver uma web desde o início, você trabalha com as áreas fundamentais da programação:back-end e front-end.

  $ npm install -g @ ionic / cli  

  $ ionic start smartpill-webui em branco  

  $ cd smartpill-webui 
 $ ionic serve  

• app-routing.module.ts. Ele permite que o usuário navegue por todas as diferentes rotas disponíveis. Certos caminhos permitem que o desenvolvedor da web transporte variáveis ​​de uma rota para outra.

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

• post.service.ts. Ele se comunica com a API. Aqui são definidas as principais interfaces (Post, Dep e Log), juntamente com a classe PostService. PostService possui as principais funções básicas para se comunicar com a API:função get, para receber informações da API; post, para criar um novo artigo na API; excluir, para excluir um artigo; e colocar, para editar um artigo existente na interface, mas excluindo os dados anteriores que ele continha.

  getPosts () {
 return this.http.get  (this.API); 
} 
 
 getDeposit () {
 return this.http.get  (this.DEPOSIT); 
} 
 
 
 getLogs () {
 return this.http.get  (this.LOGS); 
} 
 
 createPost (comprimido:string, depósito:string, peso:string, manhã:booleano, tarde:booleano, noite:booleano) {
 retornar this.http.post  (this.API, {
 pílula, 
 depósito, 
 peso, 
 manhã, 
 tarde, 
 noite, 
}); 
} 
 
 removePost (id:string) {
 return this.http.delete  (` $ {this.API} / $ {id} `); 
} 
 ...  

• Crie um novo botão de postagem

• Botão Editar postagem

   ​​
   
 Editar 
   

• Caminho com Id definido no módulo de rota

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

• Lendo se a rota possui um ID

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

• Se exibir exemplo

   
 {{editando? 
 'Atualize seu':
 'Crie seu' 
}} Depósito 
   

• Exemplo de botão If

   
 {{editando? 'Atualizar':'Enviar'}} 
   

• Seleção múltipla de tempo

   
  Clique aqui para escolher a hora do dia.  
  cancelText ="Cancel" okText ="Submit"> 
  Manhã  
  Tarde  
  Night  
  
   

• Introdução de pílulas

   
  Nome do comprimido: 
   
   

• Carregar função Post

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

• Excluindo uma postagem

  async removePost (id:string) {
 const alert =await this.alertController.create ({
 header:"Alert", 
 subHeader:"Tem certeza que você deseja deletar este depósito? ", 
 mensagem:" Não será possível recuperá-lo. ", 
 botões:[
" Cancelar ", 
 {
 texto:"Sim", 
 manipulador:() => {
 this.postService.removePost (id) .subscribe (
 (res) => {
 console.log (res); 
 this.loadPosts (); 
}, 
 (err) => console.log (err) 
); 
}, 
}, 
], 
}); 
 aguarde alert.present (); 
}  

• Obtendo registros

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

• Exibindo registros

   
  
  
  
   
   
   
  
 
 {{log.date | data:'dd / MM / aaaa'}} - {{log.date | data:'HH_mm'}} h 
 
 
 {{log.patient_name}} 
 
 

 {{log.pills}} 
 
  
  
  
  
   

Amazon Web Services

A AWS é o provedor de serviços escolhido para implantar o sistema SmartPill, pois oferece uma ampla gama de serviços dentro do mesmo ecossistema, permitindo-nos optar por uma abordagem totalmente sem servidor. Isso permite que o aplicativo se adapte às necessidades do usuário e pague apenas pelo que for usado.

Smartpill Arquitetura em nuvem

O sistema Smartpill usa uma arquitetura totalmente sem servidor usando Amazon Web Services. Isso permite que o aplicativo aumente ou diminua para ser adaptado às necessidades do usuário. A arquitetura é descrita no diagrama abaixo:

O Smartpill Dispenser usa uma placa Microchip AVR-IoT com recursos WiFi para se comunicar com o ecossistema AWS. AVR-IoT é conectado por meio do AWS IoT Core pelo protocolo MQTT. Isso permite conectividade bidirecional entre o ecossistema da nuvem e o próprio hardware. Essa comunicação é usada para enviar a mensagem de dispensa para o dispensador, bem como os eventos de confirmação do dispensador para a nuvem.

O front-end do aplicativo da web desenvolvido com a estrutura Ionic Angular NodeJS é compilado e seus arquivos estáticos são carregados para o serviço de armazenamento AWS S3. O backend do aplicativo da web é um serviço HTTT API Rest desenvolvido com AWS API Gateway que chama funções Lambda. Essas funções do Lambda se comunicam com o banco de dados DynamoDB que armazena a configuração dos comprimidos e os registros de ingestão.

A ponte de eventos da AWS é usada como um agendador para acionar os eventos de dispensa no horário correto. Este evento aciona uma função Lambda que pesquisará no banco de dados os comprimidos necessários em cada ingestão e enviará essas informações ao Dispensador SmartPill por meio do IoT Core.

AWS-IoT Core

A primeira coisa que você precisa fazer para começar a operar a placa AVR-IoT com AWS IoT Core é conectar a placa à sua conta AWS. Este processo é descrito pela Microchip nos Guias do Desenvolvedor de IoT para AWS

Com isso, você terá sua placa AVR-IoT pronta para usar em sua conta da AWS. Você pode ver isso no AWS IoT Core em Gerenciar → Guia Coisas.

Em seguida, certifique-se de que sua placa AVR-IoT tenha acesso à Internet, configurando-a com suas credenciais WiFi, conforme descrito no Guia de primeiros passos:

AWS DynamoDB

Então você vai querer configurar o aplicativo web, para isso, a primeira coisa que você precisa fazer é registrar as tabelas do DynamoDB que o aplicativo web precisa:

• smartpill-history:irá armazenar todos os registros de comprimidos tomados
• smartpill-pills:irá armazenar seus comprimidos configurados

Clique em criar tabela:

Dê a ele o nome exato e selecione "id" como a chave primária.

AWS Lambda

Certifique-se de ter AmazonDynamicDBFullAccess anexado. Para que a função Lambda possa ler / gravar no banco de dados DynamoDB. Para isso, vá até a guia Permissões:

E clique em Nome da função. Isso irá redirecioná-lo para a função de execução para esta função Lambda. Recomendamos que cada função Lambda tenha sua própria Função de Execução.

AmazonDynamoDBFullAccess deve aparecer, se não, clique em Anexar políticas e Pesquisar por "dynamodb":

Fornecer à função Lambda acesso total ao DynamoDB é seguro apenas para o propósito deste tutorial, e não deve ser feito para um ambiente de produção.

Agora vá para a configuração e adicione o código de função do repositório Github (link abaixo):

Repita isso para todas as funções do Lambda no repositório.

Em seguida, iremos configurar as integrações entre Lambda e IoT Core para que a função adequada seja executada quando a mensagem for enviada pela placa.

Vamos configurar a confirmação da mensagem de dispensação enviada pelo AVR-IoT para que a entrada de log e a notificação correspondentes possam ser geradas no banco de dados.

Vamos para AWS-IoT Core, clique em Add and Rules para configurar uma regra:

Clique em Criar nova regra e dê um nome:smartpill_confirmationpill e uma breve descrição

Em seguida, insira a seguinte instrução de consulta:

  SELECT * FROM 'confirmationpill'  

e configurar uma ação 'Enviar uma mensagem para uma função Lambda' para apontar para o 'smartpill-confirmationpill' criado anteriormente:

Você está pronto para ir para a próxima parte.

Ponte de eventos AWS

O Event Bridge se encarregará de lançar a função lambda que enviará a mensagem ao Dispensador SmartPill para dispensar a pílula no momento correto. Iremos configurar 3 eventos programados de gatilho para fazer isso. Uma para a manhã, uma para a tarde e uma para a noite.

Acesse o serviço AWS Event Bridge e clique em "Criar uma regra".

Dê a ele um nome e configure o padrão de evento Schedule como uma expressão cron:

NOTA:Leve em consideração que essas expressões cron estão no horário UTC.

Selecione a função Lambda 'smartpill-dispensepill' como um alvo:

Esta função Lambda será executada no horário definido.

Defina mais duas regras para o horário desejado nas entradas de manhã, tarde e noite.

AWS API Gateway

Vá para AWS API Gateway e clique em Create API. Escolha HTTP API e clique em Build:

Dê a ele "smartpill-webui" como um nome (ou o que você quiser, isso não importa muito)

E configure todas as funções do Lambda como Integrações:

Clique em Avançar e configure todas as rotas conforme especificado na tabela abaixo:

Finalmente, implante a API para obter um ponto de extremidade HTTP.

Alternativamente, você pode importar o arquivo JSON 'smartpill-api.json' no repositório abaixo.

AWS S3

O serviço de armazenamento AWS S3 é feito para armazenar arquivos, mas também pode atuar como um servidor da web estático, por exemplo, uma página da web. Para fazer isso, primeiro você precisa criar um Bucket.

Vá para S3 e clique em "Create a Bucket":

Dê um nome amigável (este será o seu DNS).

Agora você terá que ativar o recurso de hospedagem de sites estáticos. Vá para propriedades e vá direto para o fundo. Você encontrará isto:

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

Alguma pergunta? Leave a comment below and we will do our best to help you!