Automatizando alertas de limpeza de caixa de água em ambientes corporativos: guia prático
Aprenda a criar alertas automáticos para limpeza de caixas d'água corporativas usando scripts, APIs e agendamento inteligente. Evite riscos sanitários e multas.
Você chegou no escritório na segunda-feira e descobriu que a caixa d’água do prédio não era limpa há 14 meses. A vigilância sanitária notificou a empresa, o síndico cobra providências e a equipe de facilities não tinha nenhum alerta configurado. Como evitar que esse cenário se repita sem depender de planilhas manuais ou memória de terceiros?
A resposta está em transformar uma obrigação legal recorrente em um processo automatizado, rastreável e integrado às ferramentas que sua equipe já usa. Neste guia, você vai construir um sistema completo de alertas — do mapeamento de ativos à notificação multicanal — usando Python, agendamento nativo do Linux e integrações modernas.
Mapeamento de ativos e definição de regras
Antes de escrever uma linha de código, faça o inventário físico. Percorra o prédio, fotografe cada reservatório, anote capacidade (litros), material (fibra, polietileno, concreto), localização (cobertura, subsolo, casa de máquinas) e data da última higienização comprovada. Registre tudo em uma planilha CSV ou diretamente no banco de dados da aplicação.
A periodicidade segue a NBR 12209 e portarias estaduais: geralmente seis meses para reservatórios de água potável. Porém, edifícios com consumo elevado, água de poço ou histórico de contaminação devem adotar intervalos menores. Crie uma coluna periodicidade_dias por ativo — 180, 120 ou 90 — e outra proxima_limpeza calculada automaticamente.
Estrutura de dados e modelo mínimo
Um modelo relacional simples resolve o problema. Tabela reservatorios com campos: id, nome, localizacao, capacidade_litros, material, ultima_limpeza (DATE), periodicidade_dias (INT), proxima_limpeza (DATE), responsavel_id (FK), ativo (BOOLEAN). Tabela alertas registra cada disparo: id, reservatorio_id, data_disparo, canal (email, slack, teams, itsm), status (enviado, falha, lido), payload_json.
from sqlalchemy import Column, Integer, String, Date, Boolean, ForeignKey, DateTime, Text
from sqlalchemy.orm import relationship
from database import Base
from datetime import datetime
class Reservatorio(Base):
__tablename__ = 'reservatorios'
id = Column(Integer, primary_key=True)
nome = Column(String(100), nullable=False)
localizacao = Column(String(200))
capacidade_litros = Column(Integer)
material = Column(String(50))
ultima_limpeza = Column(Date)
periodicidade_dias = Column(Integer, default=180)
proxima_limpeza = Column(Date)
responsavel_id = Column(Integer, ForeignKey('usuarios.id'))
ativo = Column(Boolean, default=True)
responsavel = relationship('Usuario', back_populates='reservatorios')
alertas = relationship('Alerta', back_populates='reservatorio')
class Alerta(Base):
__tablename__ = 'alertas'
id = Column(Integer, primary_key=True)
reservatorio_id = Column(Integer, ForeignKey('reservatorios.id'))
data_disparo = Column(DateTime, default=datetime.utcnow)
canal = Column(String(20))
status = Column(String(20))
payload_json = Column(Text)
reservatorio = relationship('Reservatorio', back_populates='alertas')
Cálculo inteligente de datas com dias úteis
Não basta somar 180 dias corridos. Feriados municipais (aniversário da cidade), estaduais e nacionais devem ser excluídos. A biblioteca workalendar cobre o calendário brasileiro por estado e município.
from workalendar.america.brazil import Brazil, BrazilSaoPauloCity
from datetime import date, timedelta
def calcular_proxima_limpeza(ultima: date, periodicidade_dias: int, uf: str = 'SP', cidade: str = 'Sao Paulo') -> date:
"""Retorna a data da próxima limpeza considerando dias úteis."""
cal = BrazilSaoPauloCity() if cidade == 'Sao Paulo' else Brazil()
dias_adicionados = 0
data_atual = ultima
while dias_adicionados < periodicidade_dias:
data_atual += timedelta(days=1)
if cal.is_working_day(data_atual):
dias_adicionados += 1
return data_atual
def dias_uteis_ate(alvo: date, uf: str = 'SP', cidade: str = 'Sao Paulo') -> int:
"""Conta dias úteis de hoje até a data alvo."""
cal = BrazilSaoPauloCity() if cidade == 'Sao Paulo' else Brazil()
hoje = date.today()
count = 0
while hoje < alvo:
hoje += timedelta(days=1)
if cal.is_working_day(hoje):
count += 1
return count
Motor de verificação diária e disparo multicanal
O coração do sistema roda uma vez por dia via cron ou systemd timer. O script consulta todos os reservatórios ativos, calcula quantos dias úteis faltam para proxima_limpeza e dispara alertas nos limiares configurados: 30, 15, 7 e 1 dia útil antes. Cada canal tem seu adaptador.
import smtplib
import requests
import json
from email.mime.text import MIMEText
from datetime import date
from models import Reservatorio, Alerta, Session
from calculo_dias import dias_uteis_ate
LIMIARES = [30, 15, 7, 1] # dias úteis antes
def enviar_email(destino, assunto, corpo):
msg = MIMEText(corpo, 'html')
msg['Subject'] = assunto
msg['From'] = 'facilities@empresa.com'
msg['To'] = destino
with smtplib.SMTP('smtp.empresa.com', 587) as server:
server.starttls()
server.login('user', 'senha')
server.send_message(msg)
def enviar_slack(webhook_url, texto):
requests.post(webhook_url, json={'text': texto}, timeout=10)
def enviar_teams(webhook_url, titulo, corpo):
payload = {'@type': 'MessageCard', '@context': 'http://schema.org/extensions',
'themeColor': '0076D7', 'summary': titulo,
'sections': [{'activityTitle': titulo, 'text': corpo}]}
requests.post(webhook_url, json=payload, timeout=10)
def criar_chamado_itsm(reservatorio, dias_restantes):
"""Exemplo para Jira Cloud via REST API."""
url = 'https://empresa.atlassian.net/rest/api/3/issue'
auth = ('email@empresa.com', 'api_token')
headers = {'Accept': 'application/json', 'Content-Type': 'application/json'}
payload = {
'fields': {
'project': {'key': 'FAC'},
'summary': f'Limpeza caixa d\'água: {reservatorio.nome} - {dias_restantes} dias úteis',
'description': f'Reservatório: {reservatorio.nome}\nLocal: {reservatorio.localizacao}\nCapacidade: {reservatorio.capacidade_litros} L\nÚltima limpeza: {reservatorio.ultima_limpeza}\nPróxima prevista: {reservatorio.proxima_limpeza}\nResponsável: {reservatorio.responsavel.nome}',
'issuetype': {'name': 'Task'},
'assignee': {'emailAddress': reservatorio.responsavel.email}
}
}
requests.post(url, json=payload, headers=headers, auth=auth, timeout=15)
def registrar_alerta(session, reservatorio_id, canal, status, payload):
alerta = Alerta(reservatorio_id=reservatorio_id, canal=canal, status=status,
payload_json=json.dumps(payload, default=str))
session.add(alerta)
session.commit()
def main():
session = Session()
reservatorios = session.query(Reservatorio).filter_by(ativo=True).all()
for r in reservatorios:
dias = dias_uteis_ate(r.proxima_limpeza)
if dias in LIMIARES:
payload = {'reservatorio': r.nome, 'dias_uteis_restantes': dias,
'proxima_limpeza': str(r.proxima_limpeza)}
try:
enviar_email(r.responsavel.email,
f'Alerta: limpeza de caixa d\'água em {dias} dias úteis',
f'O reservatório {r.nome} precisa de limpeza até {r.proxima_limpeza}.')
registrar_alerta(session, r.id, 'email', 'enviado', payload)
except Exception as e:
registrar_alerta(session, r.id, 'email', 'falha', {'erro': str(e)})
try:
enviar_slack('https://hooks.slack.com/services/XXX/YYY/ZZZ',
f':water_drop: Limpeza de *{r.nome}* em {dias} dias úteis ({r.proxima_limpeza})')
registrar_alerta(session, r.id, 'slack', 'enviado', payload)
except Exception as e:
registrar_alerta(session, r.id, 'slack', 'falha', {'erro': str(e)})
try:
enviar_teams('https://outlook.office.com/webhook/XXX',
f'Limpeza de caixa d\'água: {r.nome}',
f'Faltam {dias} dias úteis para a limpeza programada.')
registrar_alerta(session, r.id, 'teams', 'enviado', payload)
except Exception as e:
registrar_alerta(session, r.id, 'teams', 'falha', {'erro': str(e)})
try:
criar_chamado_itsm(r, dias)
registrar_alerta(session, r.id, 'itsm', 'enviado', payload)
except Exception as e:
registrar_alerta(session, r.id, 'itsm', 'falha', {'erro': str(e)})
session.close()
if __name__ == '__main__':
main()
Integração com sensores e telemetria opcional
Se o prédio possui sensores de nível (ultrassônicos, radar ou boia magnética) com saída Modbus, LoRaWAN ou MQTT, você enriquece o alerta com dados em tempo real. Um vazamento lento ou consumo anômalo pode antecipar a necessidade de limpeza ou manutenção corretiva.
Um collector leve em Python lê o broker MQTT e grava leituras na tabela leituras_sensor (reservatorio_id, timestamp, nivel_percentual, vazao_l_min). O verificador diário consulta a última leitura e, se o nível cair abaixo de 20% sem motivo aparente, adiciona flag investigar_vazamento no payload do alerta.
Essa telemetria também alimenta dashboards no Grafana ou Power BI, dando visibilidade à gestão de facilities sem planilhas manuais. Para equipes que já usam stacks de observabilidade, o mesmo princípio de alerting as code aplicado a servidores vale para ativos hidráulicos.
Relatórios de conformidade e trilha de auditoria
A cada limpeza realizada, o responsável preenche um formulário digital (Google Forms, Microsoft Forms ou app interno) que dispara webhook para sua API. O endpoint valida os campos obrigatórios — data, empresa executora, CNPJ, responsável técnico, laudo anexo — e atualiza ultima_limpeza e proxima_limpeza do reservatório.
Um job mensal gera relatório consolidado em Markdown, commita no repositório Git privado da área de facilities e abre pull request para aprovação do gestor. O histórico de commits vira evidência documental para auditorias ISO 9001, ISO 14001 e fiscalizações do Ministério do Trabalho.
| Reservatório | Última Limpeza | Próxima Prevista | Status | Empresa Executora | Laudo |
|--------------|----------------|------------------|--------|-------------------|-------|
| Caixa Cobertura Bloco A | 2024-07-15 | 2025-01-15 | ✅ Conforme | HidroClean Ltda | [PDF](/laudos/2024-07-15_bloco_a.pdf) |
| Cisterna Subsolo Bloco B | 2024-06-20 | 2024-12-20 | ⚠️ Atrasada | - | - |
| Reservatório Casa de Máquinas | 2024-08-10 | 2025-02-10 | ✅ Conforme | AquaService | [PDF](/laudos/2024-08-10_casa_maquinas.pdf) |
> Gerado automaticamente em 2025-01-20 06:00 via `scheduler/relatorio_mensal.py`
Boas práticas de operação e evolução contínua
Trate o sistema como produto interno: versionamento semântico, changelog, testes automatizados (pytest + mocks de SMTP/HTTP) e pipeline de CI/CD que faz deploy em staging antes de produção. Documente runbooks para falhas comuns — expiração de token do Slack, mudança de API do Jira, feriado municipal não cadastrado no workalendar.
Revise trimestralmente a lista de contatos responsáveis, periodicidades e canais de notificação. Inclua o sistema no onboarding de novos analistas de facilities. Para expandir, adicione módulos de gestão de contratos com prestadores, SLA de atendimento e integração com dezjatodesentupidora.com.br/ quando a equipe interna não tiver capacidade técnica.
Automatizar alertas de limpeza de caixa d’água elimina o risco humano de esquecimento, cria evidências auditáveis e libera a equipe para tarefas de maior valor. Comece pequeno — um script, um reservatório, um canal — e evolua em ciclos curtos. A conformidade sanitária deixa de ser susto e vira rotina previsível.
Quer ver como aplicar esse mesmo padrão a outros ativos prediais? Confira nosso guia sobre automação de chamados de limpeza de caixa de água na Aclimação e o artigo sobre agendamento automatizado de limpeza de fossa em polos tecnológicos paulistanos. Para times que integram sensores em dashboards, o post sobre automatizando relatórios de hidrojateamento com Python mostra o próximo passo.
Checklist prático
Perguntas frequentes
Qual a frequência ideal para limpeza de caixas d'água em escritórios?
A norma técnica recomenda limpeza semestral, mas ambientes com alto fluxo de pessoas ou água de poço podem exigir intervalos trimestrais. Consulte a vigilância sanitária local para adequar o cronograma.
Como integrar alertas de limpeza ao sistema de chamados da empresa?
Use webhooks ou APIs REST do seu ITSM (Jira, GLPI, ServiceNow) para criar tickets automáticos quando o script detectar a data limite. Inclua no payload: local, responsável, histórico e checklists anexos.
Sensores de nível substituem a inspeção visual periódica?
Não. Sensores monitoram volume e vazamentos, mas não detectam biofilme, sedimentos ou contaminação microbiológica. A inspeção física continua obrigatória por legislação sanitária.
Qual stack mínima para rodar esse agendamento em produção?
Um servidor Linux com Python 3.10+, cron ou systemd timers, banco SQLite/PostgreSQL para logs e acesso SMTP/Slack para notificações. Containers Docker facilitam portabilidade e updates.
Como tratar feriados e fins de semana nos alertas?
Use a biblioteca `workalendar` ou `bizdays` para calcular dias úteis. Programe o alerta para disparar com 15 dias úteis de antecedência, garantindo janela para contratação e execução do serviço.
É possível versionar o histórico de limpezas em Git?
Sim. Armazene relatórios em Markdown ou JSON num repositório privado. Commits automáticos via CI/CD criam trilha de auditoria imutável, útil para certificações ISO e auditorias do Ministério do Trabalho.