Lembrete de remédio automático usando Arduino

Quando se trata de nossos entes queridos, sempre queremos mantê-los saudáveis ​​e em forma. Mas o que vai acontecer se eles ficarem doentes e esquecerem de tomar os remédios na hora certa. Estaríamos preocupados, certo? Nos hospitais, há muitos pacientes e é difícil lembrar a todos os pacientes que devem tomar os remédios na hora certa. As formas tradicionais exigem esforços humanos para lembrá-los de tomar os medicamentos na hora certa. A era digital não segue isso e podemos usar máquinas para fazer isso. A aplicação do Smart Medicine Reminder é muito ampla e pode ser usada por pacientes em casa, médicos em hospitais e em muitos outros lugares. Quando se trata de lembrar, pode haver muitas maneiras de lembrá-lo:

1. Mostre em um display
2. Enviar notificação por e-mail ou telefone
3. Usando aplicativos móveis
4. Alarme zumbido
5. Usando Bluetooth / Wi-Fi
6. Receber uma chamada
7. Lembre-se do próximo medicamento ao mesmo tempo em que lembra o horário atual

Podemos combinar formas dependendo da necessidade. Para manter as coisas simples, criamos um Lembrete de medicamento simples usando o Arduino que nos lembra de tomar medicamentos 1 ou 2 ou 3 vezes ao dia. O intervalo de tempo pode ser selecionado usando os botões. Além disso, mostra a data e a hora atuais. Iremos estendê-lo ainda mais para artigos recebidos de um projeto de IoT, nos quais uma notificação por e-mail ou SMS será enviada ao usuário. Este lembrete de medicação também pode ser integrado ao Sistema de Monitoramento de Pacientes.

Componentes necessários para lembrete de medicina automática usando Arduino

1. Arduino Uno (podemos usar outras placas Arduino também, como Pro mini, Nano)
2. Módulo RTC DS3231
3. Display LCD 16x2
4. Buzzer
5. Led (qualquer cor)
6. Tábua de pão
7. Apertar botões
8. Potenciômetro 10K
9. Resistores 10K, 1K
10. Jumper Wires

Arduino Medicine Reminder using Arduino Circuit

O diagrama de circuito completo para construir uma caixa de remédios inteligente usando Arduino é mostrado abaixo

Abaixo estão as conexões de pinos do Arduino com diferentes periféricos

Pinos Periféricos Arduino

• 2 -----------------------------> D7 de display LCD 16x2
• 3 -----------------------------> D6 de display LCD 16x2
• 4 -----------------------------> D5 de display LCD 16x2
• 5 -----------------------------> D4 de display LCD 16x2
• 7 -----------------------------> 3º botão de pressão
• 8 -----------------------------> 2º botão de pressão
• 9 -----------------------------> 1º botão de pressão
• 11 -----------------------------> Pino EN do display LCD 16x2
• 12 -----------------------------> Pino RS do display LCD 16x2
• 13 -----------------------------> + Ve Pin de Buzzer e Led
• A0 -----------------------------> Botão de Parar
• A4 -----------------------------> SDA de DS3231
• A5 -----------------------------> SCL de DS3231
• 3,3 V -----------------------------> Vcc do DS3231
• Gnd -----------------------------> Gnd

Neste projeto de lembrete de medicina, o RTC DS3231 tem interface por meio do protocolo I2C com o Arduino Uno. Você também pode usar RTC IC DS1307 para ler a hora com o Arduino. O RTC DS3231 também possui memória interna de 32k, que pode ser usada para armazenar dados adicionais. O módulo RTC é alimentado por meio do pino de 3,3 V do Arduino uno. Um display LCD 16x2 é conectado usando SPI. Um buzze r é usado para alertar e lembrar que é hora de tomar o remédio. Quatro botões são usados ​​onde cada um tem um recurso de seleção distinto. O primeiro botão é usado para lembrar de tomar o remédio uma vez por dia. O segundo botão é usado para lembrar duas vezes por dia e o terceiro botão é usado para lembrar três vezes por dia. O quarto botão é usado para parar a campainha quando o usuário ouvir o alerta.

Funcionamento do Sistema Automático de Lembrete de Medicamentos

O alarme de lembrete de pílula é alimentado com alimentação de 5V. Quando é inicializado pela primeira vez, mostra uma massagem de boas-vindas como “ Welcome to Circuit Digest ”. A tela LCD é configurada para alternar em três telas. Os 1 ^st tela mostra a massagem como “ permanecer saudável, Get Well Soon ”. A segunda tela é uma tela de ajuda que informa para pressionar o botão de seleção para selecionar qualquer intervalo de tempo para lembrar (uma / duas / três vezes por dia). O intervalo de tempo pode ser alterado no programa e pode ser configurado de acordo. No momento, corrigimos isso em três durações, ou seja, 8h, 14h e 20h.

Dividimos os intervalos de tempo em três modos. Modo 1 seleciona para tomar medicamento uma vez / dia, às 8h, quando o usuário pressiona 1 ^st de botão de pressão. O Modo 2 seleciona tomar remédio duas vezes / dia às 8h e 20h quando o usuário pressiona o ^2º botão. O Modo 3 seleciona tomar remédio três vezes / dia às 8h, 14h e 20h se o usuário pressionar o ^3º botão.

Também podemos adicionar um recurso para suspender a campainha por 10 minutos (não incluído neste projeto). Quando o usuário seleciona os slots desejados pressionando os botões, a entrada do usuário é registrada e a hora é obtida do RTC. Quando o tempo coincide com o intervalo de tempo selecionado, a campainha começa a tocar. O usuário pode parar a campainha pressionando o botão PARAR. O mesmo processo continua para o próximo lembrete de slot. O processo completo é mostrado no Vídeo fornecido no final deste artigo.

Programming Arduino UNO for Medicine Reminder

É muito fácil escrever um programa, uma vez que você tenha pensado em como lembrar de tomar os comprimidos. Aqui ele vai mostrar o lembrete no display, tocar uma campainha e indicá-lo usando LED. Também tem a opção de selecionar três intervalos de tempo (uma / duas / três vezes por dia) e quando chegar a hora começará a alertar o paciente tocando a campainha. Então, todo o sistema ficará assim:

O usuário obtém instruções de ajuda no visor> O usuário seleciona os intervalos de tempo (uma vez / dia, duas vezes / dia, três vezes / dia)> Imprimir mensagem de confirmação no visor> Tempo iniciado> Buzzer e LED inicia quando o tempo coincide com o intervalo selecionado pelo usuário> O usuário pára por pressionando um botão de parada> Fim

Podemos mudar o programa e o hardware se quisermos adicionar mais recursos. Para entender de maneira muito mais simples, dividimos o programa em pequenas funções. As funções são fáceis de entender e implementar. O programa completo é fornecido no final deste projeto. Vamos começar com o programa.

Desde então, temos usado outros periféricos como 16x2 LCD Display, RTC DS3231, então primeiro temos que incluir bibliotecas para isso. As bibliotecas necessárias são as seguintes:

(https://github.com/adafruit/RTClib)

A biblioteca EEPROM é usada para manter o controle da entrada de seleção do usuário se o Arduino não estiver ligado. E quando o usuário liga o Arduino, ele obtém o estado anterior dos botões usando a biblioteca EEPROM. A biblioteca Wire.h é usada desde que o módulo RTC DS3231 seja comunicado usando I2C.

Sempre verifique se o RTC está conectado corretamente ou se não está danificado, pois o RTC terá um papel importante no controle do tempo de todo o sistema de lembretes.

if (! rtc.begin ()) {// verifique se o rtc está conectado Serial.println ("Não foi possível encontrar RTC"); enquanto (1); } if (rtc.lostPower ()) { Serial.println ("RTC perdeu energia, vamos definir a hora!"); }

O ajuste de tempo pode ser feito de duas maneiras, automaticamente usando o tempo de compilação do sistema ou inserindo-o manualmente. Depois de definir a hora, comente as linhas abaixo, a menos que queira alterar a hora RTC novamente.

rtc.adjust (DateTime (F (__ DATE__), F (__ TIME__))); //rtc.adjust(DateTime(2019, 1, 10, 7, 59, 52));

Esta instrução switch é usada para ler o estado salvo anteriormente do botão de pressão e retomar o estado para o tempo de lembrete apropriado e preciso.

val2 = EEPROM.read (addr); // lê o valor previamente salvo do botão de pressão para começar de onde foi deixado anteriormente switch (val2) { case 1: Serial.println ("Set for 1 / day"); push1state = 1; push2state = 0; push3state = 0; pushVal = 01; pausa; caso 2: Serial.println ("Definir para 2 / dia"); push1state = 0; push2state = 1; push3state = 0; pushVal = 10; pausa; caso 3: Serial.println ("Definir para 3 / dia"); push1state = 0; push2state = 0; push3state = 1; pushVal = 11; pausa; }

Esta instrução é usada para obter os milissegundos a serem usados ​​para cronometragem e controle do ciclo de tela do intervalo definido.

currentMillisLCD = millis (); // inicia os milis para a mudança da tela LCD em um intervalo de tempo definido

Comece a ler os pinos digitais conectados aos botões.

push1state = digitalRead (push1pin); push2state = digitalRead (push2pin); push3state = digitalRead (push3pin); stopinState = digitalRead (stopPin);

A função abaixo é usada para ler o estado do botão e gravá-lo na EEPROM. Sempre que o botão é pressionado, o estado é gravado na EEPROM. Também imprime a mensagem no display LCD da escolha de entrada do usuário selecionada. Da mesma forma, as funções push2 () e push3 () são usadas.

void push1 () {// função para definir lembrete uma vez / dia if (push1state == 1) { push1state = 0; push2state = 0; push3state = 0; // pushPressed = true; EEPROM.write (addr, 1); Serial.print ("Push1 escrito:"); Serial.println (EEPROM.read (addr)); // para depuração pushVal = 1; // salva o estado do botão de ação -1 lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Conjunto de lembretes"); lcd.setCursor (0, 1); lcd.print ("para uma vez / dia!"); atraso (1200); lcd.clear (); } }

A função abaixo é usada para parar o buzzer e o led. É sempre bom dar sugestões. Imprime uma mensagem de sugestão no display “Tome medicamento com água morna”.

void stopPins () {// função para parar o zumbido quando o usuário pressiona o botão de parada if (stopinState == 1) { // stopinState = 0; // pushPressed = true; pressionado = 1; lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Take Medicine"); lcd.setCursor (0, 1); lcd.print ("com água morna"); atraso (1200); lcd.clear (); } }

A função abaixo é independente da contagem do tempo, mas sempre circula em três telas que ajudam o usuário. Como estamos mantendo um atendimento aos pacientes vamos imprimir uma mensagem de saudação pois sabemos que o apoio emocional é muito útil na cura de pacientes em um tempo mais rápido. Você pode escolher sua própria mensagem criativa. Vamos imprimir uma mensagem como “Fique saudável, melhore logo”.

A segunda tela é para dar instruções aos pacientes como “Pressione os botões para lembrete..”. A terceira tela é usada para mostrar simplesmente a data e a hora atuais.

void changeScreen () {// função para o ciclo da tela // Iniciar a troca de tela a cada intervalo definidoLCD if (currentMillisLCD - previousMillisLCD> intervalLCD) // salvar a última vez que você alterou a exibição { previousMillisLCD = currentMillisLCD; telas ++; if (telas> maxScreen) { telas = 0; // todas as telas terminadas -> começar da primeira } isScreenChanged = true; } // Começa a exibir a tela atual se (isScreenChanged) // apenas atualiza a tela se a tela for alterada. { isScreenChanged = false; // redefine para a próxima iteração switch (telas) { case getWellsoon: gwsMessege (); // mensagem de melhora logo pausa; case HELP_SCREEN: helpScreen (); // quebra de tela de instrução ; case TIME_SCREEN: timeScreen (); // para imprimir o intervalo de data e hora ; padrão: // NÃO CONFIGURADO. pausa; } } }

Esta função é usada para começar a zumbir e piscar o LED simultaneamente se o tempo selecionado for atingido.

void startBuzz () {// função para começar a zumbir quando o tempo atinge o intervalo definido // if (pushPressed == false) { if (pushpressed == 0) { Serial.println ("pushpressed é false em piscar"); currentMillis longo sem sinal = millis (); if (currentMillis - previousMillis> = intervalo) { previousMillis = currentMillis; // salve a última vez que você piscou o LED Serial.println ("Start Buzzing"); if (ledState == LOW) {// se o LED estiver apagado, ligue e vice-versa: ledState = HIGH; } else { ledState = LOW; } digitalWrite (ledPin, ledState); } } else if (pushpressed == 1) { Serial.println ("pushpressed é verdadeiro"); ledState = LOW; digitalWrite (ledPin, ledState); } }

Esta função é usada para comparar o intervalo de tempo selecionado pelo usuário às 8h e começa a tocar a campainha e a piscar o LED até que o usuário pressione o botão de parada. Da mesma forma, as funções void at2pm () e void at 8pm são usadas para iniciar a campainha e conduzidas às 14h e 20h.

void at8am () {// função para começar a zumbir às 8h DateTime now = rtc.now (); if (int (now.hour ())> = buzz8amHH) { if (int (now.minute ())> = buzz8amMM) { if (int (now.second ())> buzz8amSS) { ////// /////////////////////////////////////////////////// startBuzz (); //////////////////////////////////////////////////////// /// } } } }

É assim que você pode simplesmente fazer seu próprio Lembrete de medicamento automático usando o Arduino. Você também pode usar o ESP8266 com o Arduino para torná-lo um projeto IoT que será capaz de enviar alerta por email ao usuário.

O código completo e o vídeo de demonstração são fornecidos abaixo.