Garrafa de Água Inteligente com Arduino – Monitoramento em Tempo Real e Alertas

Componentes e Materiais

Componente	Quantidade
SparkFun Arduino Pro Mini 328 - 5V/16MHz	1
Sensor Ultrassônico à Prova d'Água	1
Relógio em Tempo Real (RTC)	1
Display 7 Segmentos 4 Dígitos Cátodo Comum (SparkFun)	1
Buzzer	1
Chave Pushbutton 12mm (SparkFun)	1
Transistor NPN Uso Geral	1
Bateria Li-Ion 1000mAh	1
Carregador USB Li-Ion (Adafruit)	1
Resistor 221 Ω	8
Resistor 1 kΩ	4
Resistor 4,75 kΩ	2

Ferramentas e Máquinas Necessárias

• Ferro de solda
• Pistola de cola quente

Aplicativos e Serviços Online

• Arduino IDE

Sobre o Projeto

Introdução

Beber água suficiente é muito importante para nossa saúde. Beber mais água pode levar a pele mais clara, melhor saúde geral, produtividade e função cerebral aprimoradas, níveis de energia aumentados e até perda de peso.

Em nossas vidas agitadas, é realmente difícil lembrar de beber água suficiente. Na maioria das vezes esquecemos de beber água seja em casa, escritório ou em movimento. Cerca de 75% dos americanos estão cronicamente desidratados o tempo todo.

Para criar um hábito saudável de beber água, é importante rastrear sua ingestão diária.

Para rastrear minha ingestão de água, tornei minha garrafa inteligente usando Arduino. Ela pode:

1. Rastrear minha ingestão diária de água
2. Rastrear média semanal de ingestão
3. Lembrar-me de beber água
4. Rastrear horário da última ingestão
5. Funcionar mais de um mês com uma única carga

Fabricando Módulo RTC

Para registrar informações de ingestão de água, precisa-se de data e hora atuais armazenadas junto com os dados acumulados. Um chip RTC como DS1307 com bateria de backup adequada fornece essa informação. A programação do chip RTC (em software) é simples e suportada na maioria dos ambientes.

Design de um módulo RTC compacto baseado no popular CI DS1307 para projetos cotidianos com microcontroladores. O DS1307 é um relógio/calendário serial de tempo real de baixo consumo, BCD binário completo, com 56 bytes de SRAM não volátil. Endereço e dados transferidos serialmente via barramento I2C bidirecional. O relógio/calendário 24h/12h fornece segundos, minutos, horas, dia, data, mês e ano, incluindo correções para ano bissexto.

Monte o módulo RTC conforme o esquemático anexo. O DS1307 requer cristal externo. Dois resistores pull-up para pinos SCL e SDA (valor ~2k a 10k, usei 4,7k). Durante soldagem, mantive o módulo o menor possível por limitação de espaço. Pode usar DS3231 em vez do DS1307 (tem oscilador de cristal interno, não precisa cristal externo). Também pode comprar módulo RTC pronto se preferir. Como o sistema operará de bateria, conectei pino VBAT do RTC ao terra sem usar célula de moeda.

Pinos Importantes do DS1307:

• Pino 5V: Quando alto, DS1307 envia dados; quando baixo, roda na célula de backup.
• GND: Terra do módulo. Terra da bateria e fonte ligados juntos.
• SCL: Pino clock I2C - comunica com microcontrolador. Conectar ao SCL do Arduino.
• SDA: Pino dados I2C - comunica com microcontrolador. Conectar ao SDA do Arduino.
• VBAT: Entrada de bateria para célula de lítio 3V padrão ou outra fonte. Deve ser aterrado se não usado.

Fabricando Placa Display 7 Segmentos

Para o módulo display usei módulo compacto auto-contido de cátodo comum contendo quatro displays numéricos 7 segmentos, bons para exibir dados numéricos com caracteres simples.

Cada segmento é multiplexado, compartilhando mesmos pontos de conexão do ânodo. Cada um dos 4 dígitos tem seu próprio ponto de conexão de cátodo comum. Isso permite ligar/desligar cada dígito independentemente. A técnica de multiplexação reduz os pinos do microcontrolador necessários de 32 para apenas 11 ou 12!

Os segmentos LED requerem resistores limitadores de corrente quando alimentados de pino lógico 5V. Valor típico 330-470Ω para 5V. Para operação com Li-ion pode ser 220Ω. Transistores drivers são recomendados para fornecer corrente adicional aos segmentos LED, pois cada pino do microcontrolador fornece/sorve ~40mA apenas. Quando todos os 7 segmentos ligados (número 8), a demanda excede 40mA.

Esta seção de display 4 dígitos 7 segmentos é conectada em torno de quatro displays LED 7 segmentos cátodo comum e quatro transistores NPN 2N2222. Resistores 1K limitam corrente de base, e resistores 220Ω limitam corrente de operação dos segmentos.

No Arduino, saídas digitais D10-D17 acionam segmentos (a-g & dp), e D6-D9 para os dígitos (D0-D3) do display 4×7.

Um botão é adicionado ao módulo display para acessar diferentes opções. Também usado para acordar Arduino do modo sleep via interrupção externa de hardware. Botão conectado ao pino digital #2 (INT0).

Conectando Placa Display com Arduino Mini Pro

Conforme esquemático, solde todos os pinos dos segmentos ao Arduino Mini. Solde 4 pinos comuns ao coletor do transistor. Bases dos transistores conectadas aos pinos do Arduino. Após conectar display, conecte botão ao pino digital 2 (INT0). Certifique-se de conectar botão ao pino 2 pois implementaremos interrupção externa para acordar Arduino do sleep usando este botão.

Conectando Módulo RTC e Buzzer

Conecte o módulo RTC feito anteriormente ao Arduino. SDA do módulo → SDA (A4) do Arduino. SCL do módulo → SCL (A5) do Arduino. Conecte buzzer ao Arduino.

Conexões:

• RTC → Arduino Mini Pro: SDA → A4, SCL → A5
• Buzzer → D3

Fixando Sensor Ultrassônico na Tampa da Garrafa

Faça um furo na tampa da garrafa conforme imagem. Passe quatro fios do sensor ultrassônico pelo furo e fixe o sensor no centro da tampa. Sensor deve ficar no lado interno da tampa, posicionado no centro.

Conexões:

• Sensor Ultrassônico → Arduino Mini Pro: VCC → VCC, GND → GND, Trigger → D4, Echo → D5

Carregando Programa e Testando

Após todas as conexões, hora de carregar o programa no Arduino e testar funcionalidade. Várias bibliotecas necessárias: OneButton para interface do botão. Como opera de bateria, consumo é importante. Implementei modo sleep no sketch. Watchdog timer e interrupção externa de hardware acordam Arduino do sleep. Arduino faz leitura do sensor 3 vezes, faz média e calcula informações necessárias, exibe por 10 segundos e entra em sleep por 1 minuto. Acorda a qualquer momento com botão pressionado no INT0 (pino digital 2). Para ver informações de ingestão, pressione botão a qualquer momento. Sem pressão, faz leitura a cada 1 minuto. Para modo sleep usei biblioteca Arduino Low-Power. Para ler tempo do DS1307 usei biblioteca DS1307RTC. Adicione todas as bibliotecas ao ambiente para compilar.

Explico brevemente o algoritmo de cálculo. Ver arquivo anexo para sketch completo. Cálculo feito da média de 5 leituras do sensor para precisão. Leitura diária resetada a cada 24h para novo dia.

Média de ingestão preparada da média dos últimos 7 dias de ingestão diária. Se 2 horas passarem sem ingestão, alerta usuário com bip duplo a cada 15 minutos e para por 2 horas após beber água.

Baixe o código anexo e carregue no Arduino Mini Pro. Conecte todos os módulos e alimente para testar se todos componentes funcionam. Se display mostra resultado, parabéns! Parte difícil feita.

Fixando Arduino na Tampa da Garrafa

Use cola quente para fixar Arduino Mini no lado superior da tampa. Lembre-se de fixar todos componentes na tampa. Coloque cola suficiente para fixação firme.

Fixando Bateria e Módulo Carregador

Fixe bateria Li-ion sobre o Arduino. Cuidado com curto-circuito da bateria com pinos expostos. Conecte módulo carregador com a tampa. Mantenha porta USB acessível do lado externo para fácil conexão ao carregador.

Tornando Todos os Circuitos à Prova d'Água

Após conectar todos componentes, hora de tornar dispositivo completamente à prova d'água. Muito importante pois é garrafa d'água e água pode cair no circuito danificando-o. Para impermeabilizar, coloque cola suficiente em todas partes externas dos circuitos exceto porta USB. Pode modelar a tampa com cola para ficar redonda como tampa original.

Não mergulhe a tampa na água.

Aproveite!

Código

Sketch Arduino

// Funções de data/hora usando DS1307 RTC via I2C e Wire lib
#include <Time.h>
#include <TimeLib.h>
#include <Wire.h>
#include <DS1307RTC.h>
#include "LowPower.h"
#include "OneButton.h"

OneButton button(2, true);
const byte interruptPin = 2;
volatile int state = 0;
const int trigPin = 4;
const int echoPin = 5;
int piezoPin = 3;
const int digit[4] = {9,6,7,8};
int digit_value[4];
int digit_value1[4];
int button_press_count = 1;
const int segment[8] = {16,10,12,14,15,17,11,13};
const byte number[10][8] = {
  {1,1,1,1,1,1,0,0}, //0
  {0,1,1,0,0,0,0,0}, //1
  {1,1,0,1,1,0,1,0}, //2
  {1,1,1,1,0,0,1,0}, //3
  {0,1,1,0,0,1,1,0}, //4
  {1,0,1,1,0,1,1,0}, //5
  {1,0,1,1,1,1,1,0}, //6
  {1,1,1,0,0,0,0,0}, //7
  {1,1,1,1,1,1,1,0}, //8
  {1,1,1,1,0,1,1,0}  //9
};
const byte d[8] = {0,1,1,1,1,0,1,1};
const byte a[8] = {1,1,1,0,1,1,1,1};
const byte r[8] = {0,0,0,0,1,0,1,1};
const byte t[8] = {0,0,0,1,1,1,1,1};

int seconds, minutes, hours;
int water_in_ounch[15];
int water_intake_ounch[15];
int water_intake_days[7];
int water_intake_times = 0;
int previous_water_amount = 0;
int total_water_intake_today = 0;
int average_intake_last_week = 0;
int inatke_day = 1;
float average_water_level = 0;
int water_amount_in_ounce = 0;
int idle_time = 0;
int intake_day = 1;
int previous_value = 0;

void setup() {
  Serial.begin(9600);
  pinMode(interruptPin, INPUT_PULLUP);
  for(int i=6; i<=17; i++) pinMode(i, OUTPUT);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  button.attachClick(pressed);
  button.attachDoubleClick(doubleclick);
  button.attachLongPressStart(longPressStart);
  button.attachDuringLongPress(longPress);
}

long previous_state = millis();
int count = 1;
int daily_intake = 0;
int weekly_intake = 0;
long sleep_time = millis();

void loop() {
  read_time();
  button.tick();
  calculation();
  daily_intake = total_water_intake_in_day();
  weekly_intake = average_water_intake_last_week();
  
  if(button_press_count == 1){ display_d(); display_number(daily_intake); }
  else if(button_press_count == 2){ display_a(); display_number(weekly_intake); }
  else if(button_press_count == 3){ display_r(); display_number(water_amount_in_ounce); }
  else if(button_press_count == 4){ display_first_2(hours); display_last_2(minutes); }
  
  if(idle_time >= 120){ alert(); alert(); }
  
  if((millis() - sleep_time) >= 15000){
    display_off();
    attachInterrupt(digitalPinToInterrupt(interruptPin), blank, FALLING);
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
    detachInterrupt(digitalPinToInterrupt(interruptPin));
    sleep_time = millis();
  }
}

// Funções de display, leitura de sensor, cálculo de ingestão, alertas, etc.
// ... (código completo disponível no projeto original)

Esquemáticos

Esquemáticos do circuito RTC, display 7 segmentos e conexões gerais disponíveis na seção de esquemáticos do projeto original.