Apostila Técnica: Monitoramento de

Ambiente com Raspberry Pi 3+

Professor João Paulo Machado
Bacharel e Licenciado em Computação
Especialista em Data Center

1. Introdução
Este documento técnico apresenta o desenvolvimento de um sistema de monitoramento de
ambiente baseado em sensores integrados ao Raspberry Pi 3 Model B+. A proposta visa
fornecer uma base robusta e replicável para ambientes críticos como racks de servidores,
laboratórios de pesquisa e data centers de pequeno porte. O projeto enfatiza a simplicidade
de implementação, o baixo custo e a flexibilidade de adaptação para diferentes sensores. A
plataforma permite a leitura de variáveis ambientais como temperatura, umidade, presença
de fumaça, corrente elétrica, vazamento de água e abertura de portas.

2. Plataforma de Hardware
O Raspberry Pi 3 Model B+ foi selecionado como unidade central de coleta e controle por sua
versatilidade, baixo consumo de energia e ampla compatibilidade com sensores analógicos e
digitais. Equipado com uma CPU quad-core de 1.4GHz, 1GB de RAM, conectividade Wi-Fi,
Bluetooth e GPIOs, o modelo é adequado para aplicações embarcadas com acesso a rede local.

O sistema operacional recomendado é o Raspberry Pi OS (Raspbian) Lite 64 bits, por sua

estabilidade, suporte à comunidade e leveza, ideal para aplicações headless em produção.

3. Arquitetura do Sistema de Monitoramento

A arquitetura do sistema se baseia em sensores distribuídos conectados ao Raspberry Pi.
Cada sensor possui um script dedicado de leitura, responsável por capturar os dados e
disponibilizá-los localmente. Um script centralizador — denominado agregador — orquestra
a execução dos scripts individuais e pode, futuramente, enviar os dados para um banco local
ou remoto, via MQTT, HTTP ou banco de dados relacional.

4. Lista de Compras e Materiais

Para montar o sistema completo de monitoramento com o Raspberry Pi, é necessário adquirir
os seguintes componentes. A tabela a seguir apresenta a lista de compras recomendada, com
descrição técnica de cada item, quantidade mínima recomendada para uma instalação básica
(1 rack com 3 zonas de monitoramento: base, centro e topo) e observações sobre instalação
ou compatibilidade:

Item Descrição Técnica Qtd. Mínima Observações

Raspberry Pi 3 Placa computacional 1 Responsável por

Model B+ ARMv8 64-bit, 1GB orquestrar o
RAM, GPIO 40 pinos sistema e executar
os scripts

Cartão microSD Classe 10, mínimo 1 Armazenamento do

de 16 GB SO e scripts Python

Sensor DHT22 Sensor digital de 3 Instalado em

temperatura e diferentes zonas do
umidade - precisão rack
de ±0.5°C e ±2% UR

Sensor MLX90614 Sensor de 1 Ideal para leitura

temperatura por sem contato de
infravermelho, superfícies
comunicação I2C aquecidas

Sensor DS18B20 Sensor digital de 3 Alta precisão, ideal

temperatura, para cabos ou
protocolo 1-Wire líquidos

Sensor ACS712 Sensor de corrente 1 Usado para leitura

(AC/DC) baseado de consumo elétrico
em efeito Hall por fase

Sensor MQ-2 Sensor de gás 1 Segurança e

inflamável/fumaça - monitoramento
saída ambiental
analógica/digital

Sensor de Base condutiva com 1 Instalado no piso

vazamento de água acionamento digital elevado para
detecção precoce

Sensor Reed Switch Sensor magnético 1 Monitoramento de

com contatos secos abertura de porta
do rack
 Fonte 5V 3A Fonte de 1 Alimentação do
alimentação com Raspberry Pi
conector micro-USB

Cabos Jumper Cabos macho-fêmea Diversos Conexões entre

e fêmea-fêmea sensores e GPIO

Resistores pull-up 4.7 kΩ e 10 kΩ Conforme sensor Necessários para

DS18B20, I2C e
outros

5. Sensores e Scripts
Esta seção apresenta os sensores utilizados no projeto, com descrição técnica detalhada de
funcionamento, melhores práticas de instalação e explicação aprofundada de seus
respectivos scripts Python. Cada sensor desempenha um papel importante na coleta de dados
ambientais ou elétricos dentro do ambiente monitorado. Ao final, o script agregador é
responsável por centralizar as leituras e organizar os dados para envio ou armazenamento.

5.1 Sensor DHT22 – Temperatura e Umidade

O sensor DHT22 é amplamente utilizado para medir a temperatura e a umidade relativa do
ar. Ele possui uma boa precisão (±0.5 °C para temperatura e ±2% para umidade) e um tempo
de resposta adequado para monitoramento em ambientes como racks de TI. Opera com
tensão de 3,3V a 5V e possui saída digital, facilitando a conexão direta ao GPIO do Raspberry
Pi.

A leitura dos dados requer tempo mínimo entre coletas (superior a 2 segundos), sendo
importante respeitar esse intervalo nos scripts. A biblioteca mais comum para sua utilização
é a `Adafruit_DHT`.

Script: leitor_dht22_rpi.py

import Adafruit_DHT
import time

# Define o tipo de sensor e o pino GPIO

sensor = Adafruit_DHT.DHT22
gpio_pin = 4 # Altere para o pino que estiver usando no seu Raspberry Pi

def read_dht22():
humidity, temperature = Adafruit_DHT.read_retry(sensor, gpio_pin)
if humidity is not None and temperature is not None:
return round(temperature, 2), round(humidity, 2)
else:
 return None, None

if __name__ == "__main__":
try:
while True:
temp, hum = read_dht22()
if temp is not None:
print(f"Temperatura: {temp} °C | Umidade: {hum} %")
else:
print("Falha na leitura do sensor DHT22.")
[Link](10)
except KeyboardInterrupt:
print("Encerrado pelo usuário.")

Explicação do script:

• A biblioteca `Adafruit_DHT` é utilizada para se comunicar com o sensor. É necessário

instalá-la previamente via `pip install Adafruit_DHT`.
• O sensor está conectado ao pino GPIO 4, conforme especificado na variável `GPIO_PINO`.
• A função `read_retry` tenta realizar até 15 leituras consecutivas para garantir uma leitura
válida.
• Os valores são impressos com uma casa decimal e acompanhados das unidades °C e %.
• Este script pode ser chamado a cada 5 segundos pelo script agregador ou agendado via cron.

5.2 Sensor MLX90614 – Temperatura Infravermelha (I2C)

O MLX90614 é um sensor de temperatura infravermelho que realiza medições sem contato.
É ideal para avaliar a temperatura de superfícies ou dispositivos aquecidos como
equipamentos de TI, fontes de alimentação ou inversores, especialmente em locais onde a
medição por contato não é prática. O sensor comunica-se com o Raspberry Pi através da
interface I2C, utilizando os pinos GPIO 2 (SDA) e GPIO 3 (SCL).

O MLX90614 mede duas temperaturas: a temperatura ambiente e a de um objeto apontado

por sua lente frontal. A precisão é de aproximadamente ±0,5 °C. Requer alimentação de 3,3V
a 5V e resistor pull-up nos pinos SDA e SCL, dependendo da placa utilizada (muitas já
possuem esses resistores integrados).

Script: leitor_mlx90614_rpi.py

import time
from smbus2 import SMBus
from mlx90614 import MLX90614

# Inicializa o barramento I2C e o sensor

bus = SMBus(1)
sensor = MLX90614(bus, address=0x5A)

def read_mlx90614():
ambient_temp = sensor.get_ambient()
object_temp = sensor.get_object_1()
return round(ambient_temp, 2), round(object_temp, 2)

if __name__ == "__main__":
try:
while True:
ambient, object_ = read_mlx90614()
print(f"Temperatura Ambiente: {ambient} °C | Objeto (Hotspot): {object_} °C")
[Link](10)
except KeyboardInterrupt:
print("Encerrado pelo usuário.")
finally:
[Link]()

Explicação do script:

• A biblioteca `smbus2` e `adafruit_mlx90614` são utilizadas para comunicação I2C com o

sensor.
• O sensor é inicializado através do endereço I2C padrão 0x5A.
• As leituras `object_temperature` e `ambient_temperature` são impressas com precisão de 2
casas decimais.
• É importante garantir que o barramento I2C esteja habilitado no Raspberry Pi com `raspi-
config` > Interfacing Options > I2C.

Explicação do script:

• O script lê diretamente os arquivos do sistema em `/sys/bus/w1/devices/`, onde os

sensores DS18B20 aparecem após o carregamento dos módulos `w1_gpio` e `w1_therm`.

• A função `read_temp_raw` abre o arquivo de leitura do sensor e retorna o conteúdo como

string. Esse arquivo representa os dados binários convertidos pela interface 1-Wire.

• A função `read_temp` interpreta os dados, verifica se a leitura está OK (CRC válido) e então
extrai o valor da temperatura em milicelsius, convertendo-o para °C.

• O ID do sensor (por exemplo, `28-xxxxxxxxxxxx`) deve ser configurado de acordo com o

número de série específico do sensor, que pode ser identificado ao listar os dispositivos em
`/sys/bus/w1/devices/`.

• Para ativar o suporte a 1-Wire no Raspberry Pi, deve-se habilitar a interface via `raspi-
config` ou adicionar `dtoverlay=w1-gpio` ao arquivo `/boot/[Link]`.
• O resistor de pull-up de 4,7 kΩ é obrigatório entre os pinos de dados e VCC para
funcionamento adequado.

5.4 Sensor ACS712 – Medição de Corrente (AC/DC)

O sensor ACS712 é baseado no princípio do efeito Hall para medição de corrente alternada
(AC) ou contínua (DC). Ele fornece uma saída analógica proporcional à corrente medida, com
um valor de tensão centrado em 2,5V (zero corrente). A leitura da corrente é feita por meio
da conversão da saída analógica utilizando o conversor analógico-digital (ADC).

O Raspberry Pi não possui conversor ADC nativo, portanto, para utilizar o ACS712 é
necessário o uso de um módulo externo como o MCP3008, que se comunica via protocolo SPI.
A resolução de leitura e o ruído do sinal devem ser considerados, sendo recomendável a
média de múltiplas amostras para uma leitura estável. O ACS712 está disponível em três
versões: 5A, 20A e 30A. Deve-se escolher o modelo adequado à corrente da carga a ser
monitorada.

Script: leitor_acs712_rpi.py

import time
import spidev

# Inicializa SPI
spi = [Link]()
[Link](0, 0)
spi.max_speed_hz = 1350000

def read_adc(channel):
adc = spi.xfer2([1, (8 + channel) << 4, 0])
data = ((adc[1] & 3) << 8) + adc[2]
return data

def read_current(channel=0):
raw_value = read_adc(channel)
voltage = (raw_value * 3.3) / 1023.0
current = (voltage - 2.5) / 0.1 # Ajuste para o modelo do ACS (5A = 185mV/A)
return round(current, 2)

if __name__ == "__main__":
try:
while True:
current = read_current(0)
print(f"Corrente estimada: {current} A")
[Link](5)
except KeyboardInterrupt:
 print("Encerrado pelo usuário.")
finally:
[Link]()

Explicação do script:

• A biblioteca `spidev` é utilizada para estabelecer comunicação SPI entre o Raspberry Pi e o

conversor ADC MCP3008.

• A função `read_channel` faz a leitura de um canal analógico do MCP3008 e converte os dados

do protocolo SPI em um valor de 10 bits (0 a 1023).

• O valor de leitura é convertido em tensão, considerando o valor de referência (3.3V).

• A corrente é estimada assumindo que 2.5V representa zero corrente. A sensibilidade varia
com o modelo do ACS712 (por exemplo, 185mV/A para o modelo de 5A).

• Recomenda-se aplicar filtros e médias móveis para estabilizar leituras e evitar flutuações
de ruído.

5.5 Sensor MQ-2 – Gás e Fumaça

O sensor MQ-2 é utilizado para detecção de gases inflamáveis e fumaça em ambientes
fechados. É capaz de identificar gases como GLP, metano, butano, álcool, hidrogênio e
monóxido de carbono. Ele possui uma saída analógica proporcional à concentração de gás
detectado e, dependendo da placa, uma saída digital configurável com limiar via
potenciômetro integrado.

A leitura analógica fornece maior resolução e permite detectar variações graduais na

concentração de gases. Para uso com o Raspberry Pi, que não possui entrada analógica nativa,
é necessário o uso de um conversor ADC, como o MCP3008. O MQ-2 possui um tempo de pré-
aquecimento necessário de 20 a 30 segundos para estabilização após energização.

Script: leitor_mq2_rpi.py

import time
import [Link] as GPIO

# Configurações do GPIO
mq2_pin = 17 # Altere para o pino que estiver usando no seu Raspberry Pi

[Link]([Link])
[Link](mq2_pin, [Link])

def read_mq2():
estado = [Link](mq2_pin)
 if estado == [Link]:
return "Fumaça/Gás detectado!"
else:
return "Ambiente limpo."

if __name__ == "__main__":
try:
while True:
status = read_mq2()
print(status)
[Link](5)
except KeyboardInterrupt:
print("Encerrado pelo usuário.")
finally:
[Link]()

Explicação do script:

• O script utiliza o `spidev` para comunicação com o MCP3008, que converte a saída analógica
do MQ-2 em um valor digital (0 a 1023).

• A função `read_channel` realiza a leitura da porta analógica definida para o sensor (canal 0
no exemplo).

• O valor retornado representa a intensidade da presença de gás no ambiente, quanto maior,

maior a concentração.

• Para conversão em ppm, seria necessário um algoritmo de calibração baseado na curva do

sensor, o que exige um ambiente controlado e conhecimento da equação de resposta do MQ-
2.

• Recomenda-se utilizar o sensor em posição elevada dentro do rack ou sala, pois gases
quentes tendem a subir.

5.6 Sensor de Vazamento de Água – Detecção de Líquido

O sensor de vazamento de água funciona por meio da condução elétrica entre duas trilhas
metálicas. Quando líquido (água ou fluido condutivo) entra em contato com os eletrodos, um
circuito é fechado e o sensor fornece um sinal digital (nível alto ou baixo). Ele é amplamente
utilizado em pisos elevados de data centers, próximo a bandejas de ar-condicionado ou
entradas de dutos.

O modelo mais comum é baseado no sensor YL-83 ou YL-38, que pode ser usado com ou sem
um comparador analógico. A instalação deve ser feita em local plano, com os eletrodos
voltados para baixo e preferencialmente fixados com fita dupla face para garantir contato
com o piso.
Script: leitor_sensor_agua_rpi.py

import time
import [Link] as GPIO

# Configurações do GPIO
agua_pin = 27 # Altere para o pino que estiver usando no seu Raspberry Pi

[Link]([Link])
[Link](agua_pin, [Link])

def read_water_sensor():
estado = [Link](agua_pin)
if estado == [Link]:
return "Água detectada! (Risco de inundação)"
else:
return "Ambiente seco."

if __name__ == "__main__":
try:
while True:
status = read_water_sensor()
print(status)
[Link](5)
except KeyboardInterrupt:
print("Encerrado pelo usuário.")
finally:
[Link]()

Explicação do script:

• O sensor é conectado a um pino digital do GPIO (no exemplo, GPIO 17).

• A biblioteca `[Link]` é usada para configurar o pino como entrada, com leitura digital
simples.

• O script imprime o estado lógico lido: se `1`, significa ausência de água; se `0`, significa
presença de líquido entre os eletrodos.

• O script pode ser executado ciclicamente pelo agregador ou configurado como evento
interrupt-driven para alertas imediatos.

• Recomenda-se usar mais de um sensor em áreas críticas ou próximas a locais onde a água
pode infiltrar.
5.7 Sensor Reed Switch – Monitoramento de Abertura de Porta
O Reed Switch é um sensor magnético que atua como um interruptor de contato seco. Ele é
ativado pela proximidade de um campo magnético, normalmente gerado por um pequeno
ímã permanente. Quando o ímã se aproxima do sensor (geralmente instalado na moldura da
porta ou rack), os contatos internos se fecham ou se abrem, alterando o estado lógico lido
pelo Raspberry Pi.

Esse tipo de sensor é largamente utilizado em sistemas de alarme e controle de acesso. No

contexto de racks de TI, ele permite monitorar aberturas indevidas de portas ou alterações
físicas no ambiente. Sua instalação deve garantir que o sensor e o ímã fiquem alinhados
quando a porta estiver fechada.

Script: leitor_reed_switch_rpi.py

import time
import [Link] as GPIO

# Configurações do GPIO
reed_pin = 22 # Altere para o pino correspondente ao seu reed switch

[Link]([Link])
[Link](reed_pin, [Link], pull_up_down=GPIO.PUD_UP)

def read_reed_switch():
estado = [Link](reed_pin)
if estado == [Link]:
return "Porta aberta!"
else:
return "Porta fechada."

if __name__ == "__main__":
try:
while True:
status = read_reed_switch()
print(status)
[Link](2)
except KeyboardInterrupt:
print("Encerrado pelo usuário.")
finally:
[Link]()

Explicação do script:
• O script utiliza a biblioteca `[Link]` para configurar o pino digital (GPIO 18 no exemplo)
como entrada.

• O estado lógico do pino é lido continuamente: `0` significa porta fechada (ímã próximo), `1`
significa porta aberta (ímã ausente).

• Um `try/except` garante encerramento limpo da leitura com `CTRL+C` e liberação dos

recursos do GPIO.

• Pode ser usado para log de eventos, alertas de segurança e ativação de câmera de vigilância
em racks sensíveis.

5.8 Script Agregador – Centralização das Leituras

O script agregador tem como função centralizar a execução de todos os scripts individuais
dos sensores. Ele pode ser executado periodicamente via cron, systemd ou diretamente por
aplicações externas. O objetivo principal é consolidar as leituras, padronizar o formato de
saída e eventualmente realizar o envio para sistemas externos via HTTP, MQTT ou armazenar
localmente.

O modelo atual executa sequencialmente cada script de sensor como subprocesso,

capturando suas saídas padrão. Esse modelo é ideal para pequenos ambientes e
prototipagem, mas pode ser adaptado para leitura paralela, inclusão de timeouts e detecção
de falhas por sensor.

Script: agregador_dcim_rpi.py

import time
from threading import Thread

# Importações dos módulos locais

import leitor_ds18b20_rpi as ds18b20
import leitor_dht22_rpi as dht22
import leitor_mlx90614_rpi as mlx
import leitor_mq2_rpi as mq2
import leitor_sensor_agua_rpi as agua
import leitor_reed_switch_rpi as reed
import leitor_acs712_rpi as acs

def loop_ds18b20():
while True:
for folder in ds18b20.device_folders:
temp = ds18b20.read_temp(folder)
print(f"[DS18B20] {[Link]('/')[-1]}: {temp:.2f} °C")
[Link](10)
def loop_dht22():
while True:
temp, hum = dht22.read_dht22()
if temp is not None:
print(f"[DHT22] Temp: {temp} °C | Umidade: {hum} %")
[Link](10)

def loop_mlx():
while True:
ambient, object_ = mlx.read_mlx90614()
print(f"[MLX90614] Ambiente: {ambient} °C | Objeto: {object_} °C")
[Link](10)

def loop_mq2():
while True:
status = mq2.read_mq2()
print(f"[MQ-2] {status}")
[Link](5)

def loop_agua():
while True:
status = agua.read_water_sensor()
print(f"[Sensor Água] {status}")
[Link](5)

def loop_reed():
while True:
status = reed.read_reed_switch()
print(f"[Reed Switch] {status}")
[Link](2)

def loop_acs():
while True:
current = acs.read_current(0)
print(f"[ACS712] Corrente estimada: {current} A")
[Link](5)

if __name__ == "__main__":
try:
threads = [
Thread(target=loop_ds18b20),
Thread(target=loop_dht22),
Thread(target=loop_mlx),
 Thread(target=loop_mq2),
Thread(target=loop_agua),
Thread(target=loop_reed),
Thread(target=loop_acs),
]
for t in threads:
[Link] = True
[Link]()
while True:
[Link](1)
except KeyboardInterrupt:
print("Encerrado pelo usuário.")

Explicação do script:

• O módulo `subprocess` é utilizado para chamar os scripts individuais dos sensores.

• As saídas são capturadas como texto e exibidas no terminal ou podem ser armazenadas em
arquivos ou bancos de dados.

• O modelo atual usa caminho relativo, assumindo que todos os scripts estejam no mesmo
diretório do agregador.

• Para ambientes maiores, recomenda-se transformar este agregador em um daemon com

threads paralelas, timeout por sensor e buffer de armazenamento para operação offline.

• Futuramente pode ser integrado a sistemas DCIM ou SCADA por meio de protocolos
industriais ou APIs REST.

6. Considerações para Instalação Física

A correta instalação dos sensores em campo é essencial para garantir medições precisas,
confiáveis e úteis para análise e resposta operacional. A seguir, destacam-se as melhores
práticas para posicionamento e fixação de cada sensor, com base na arquitetura típica de um
ambiente de racks ou micro data center.

• Sensores de Temperatura (DHT22 e DS18B20): instalar ao menos três por rack,

posicionados no topo, meio e base. Isso permite identificar gradientes térmicos verticais
causados por falhas de insuflação ou exaustão.

• Sensor MLX90614: ideal para medição de hotspots, deve ser apontado para equipamentos
de alta dissipação térmica, como storages e switches.

• Sensor de Corrente ACS712: utilizar modelos conforme o nível de corrente esperado.

Instalar próximo ao ponto de alimentação do rack ou PDU. Atenção à isolação.
• Sensor de Vazamento de Água: instalar sob o piso elevado, próximo a linhas de água gelada,
tubulações ou bandejas de condensado.

• Sensor MQ-2: posicionar na parte superior do ambiente para detecção precoce de fumaça e
gases quentes.

• Reed Switch: instalar com o ímã na porta do rack e o sensor fixo na moldura. Alinhar para
garantir o acionamento apenas com a porta totalmente fechada.

7. Conclusão
O sistema de monitoramento baseado em Raspberry Pi 3+ apresentado nesta apostila oferece
uma plataforma eficiente, econômica e altamente customizável para supervisão ambiental
em racks e pequenos data centers. A modularidade dos sensores permite que a solução seja
expandida gradualmente, incorporando novos pontos de medição ou se integrando a
plataformas maiores de gestão como sistemas DCIM, SCADA ou plataformas de IoT
industriais.

Com o avanço da computação de borda (edge computing), soluções como essa tornam-se
essenciais para garantir a disponibilidade e segurança de ambientes críticos em locais
remotos ou de difícil acesso, onde soluções tradicionais seriam economicamente inviáveis. A
migração futura para microcontroladores como ESP32 também poderá ser explorada,
reduzindo ainda mais os custos e o consumo energético sem abrir mão da funcionalidade.

8. Referências Bibliográficas
ASSOCIAÇÃO BRASILEIRA DE NORMAS TÉCNICAS. NBR ISO/IEC 22237: Tecnologia da
informação — Infraestrutura e instalações de data centers — Parte 1 a 6. Rio de Janeiro:
ABNT, 2021.

RASPBERRY PI FOUNDATION. Raspberry Pi Documentation. Disponível em:

[Link] Acesso em: jul. 2025.

ADA FRUIT INDUSTRIES. Sensor Libraries and Tutorials. Disponível em:

[Link] Acesso em: jul. 2025.

DATASHEET – DHT22 Temperature and Humidity Sensor. Aosong Electronics Co., Ltd.

DATASHEET – DS18B20 Programmable Resolution 1-Wire Digital Thermometer. Maxim

Integrated, 2018.

DATASHEET – MLX90614. Melexis Technologies.

DATASHEET – ACS712 Hall Effect-Based Linear Current Sensor. Allegro Microsystems.

DATASHEET – MQ-2 Semiconductor Sensor for Combustible Gas. Hanwei Electronics.