MONIORAMENTO DE MOTORES ELÉTRICOS

Bruno César de Carvalho, Everton Dias, Filipe Bernardo Lima, Marco Tulio
Martins de Melo, Mauricelio Perdigão Muniz, Thalison Henrique Silva de Sá.

Resumo
Um sistema de monitoramento de motores elétricos foi concebido utilizando o Arduino, permitindo o
acompanhamento contínuo do desempenho e da condição dos motores. Sensores de corrente, tensão,
temperatura, umidade e vibração são integrados ao Arduino para capturar dados em tempo real. Essas
informações são processadas pelo Arduino, que executa um programa capaz de identificar e gerar um
alerta sobre possíveis anomalias, fortalecendo a prática de manutenção preditiva. Essa abordagem não
só eleva a eficiência operacional, mas também reduz substancialmente os riscos associados a falhas
imprevistas nos motores elétricos.

Palavras-chave: Monitoramento. Motores. Programa. Falha. Eficiência.

Área do Conhecimento: Engenharia Elétrica.

Introdução Este projeto integrativo incorpora uma

O setor industriário brasileiro consome cerca
de 40% da energia utilizada no país, e 70% do
consumo da indústria é por parte de motores
elétricos. Com isso, é possível imaginar a
tamanha relevância dos motores elétricos em
nossa atualidade e a importância da
manutenção desse equipamento para fazer com
que opere de maneira constante e em condições
ideais, Garcez (2021).
A manutenção desse projeto se baseia em
uma categoria de manutenção planejada
(realizada com planejamento prévio, e não
necessariamente corrige algum problema, tem
caráter antecipativo (Garcez, 2021, p.14))
chamada de manutenção preditiva, relacionada
ao conhecimento antecipado dos parâmetros de
funcionamento e às condições reais que indicam
o seu nível de desgaste ou processo de
degradação. Este tipo de manutenção tem como
principal função tentar estimar o tempo de vida
útil dos componentes das máquinas,
equipamentos e as condições para que esse
tempo de vida útil seja bem aproveitado
(Evandro et al., 2020, p.3).
O avanço tecnológico impulsiona a
necessidade de sistemas eficientes de
monitoramento para motores, visando otimizar o
desempenho e prevenir falhas. Em contraste
com outras abordagens de monitoramento,
nossa equipe propõe uma metodologia que
consiste na coleta síncrona e tratamento de
dados, combinando a versatilidade da
plataforma Arduino com um programa
customizado desenvolvido internamente.
variedade de sensores para medir corrente,
tensão, temperatura, potência, fator de potência,
consumo de energia, umidade e vibração. A
coleta e análise desses dados possibilitarão a
implementação de estratégias de manutenção
preditiva mais eficazes, reduzindo o tempo de
inatividade e prolongando a vida útil dos
motores.
A finalidade essencial deste trabalho é
apresentar um novo sistema de monitoramento,
que inclui o desenvolvimento de um software
customizado para operar em conjunto com a
plataforma Arduino em tempo real. Combinando
essas tecnologias, visa-se a otimização do
desempenho do motor e a prevenção proativa
de falhas, representando um avanço
significativo no campo do monitoramento
industrial.
Metodologia
A equipe optou por uma abordagem de A
equipe optou por uma abordagem de pesquisa
qualitativa como prioridade, devido aos objetivos
iniciais de obter uma compreensão profunda e
abrangente do tema em questão. As pesquisas
foram direcionadas a dissertações, trabalhos
acadêmicos disponíveis online e materiais
audiovisuais relevantes. Essa busca por
informações teve como propósito estabelecer
uma base sólida para o estudo de motores
elétricos e, consequentemente, para o
desenvolvimento do protótipo de monitoramento
proposto.

Trabalho Integrador – Engenharia Elétrica 1

 Depois dos estudos, foi decidida a
construção de um projeto que se enquadrasse
aos variados tipos de parâmetros. Inspirados
por um artigo, o grupo se preparou para montar
um protótipo que adequasse essas unidades
junto ao Arduino, complementado por um
programa. Após uma breve análise da
idealização do trabalho em geral, o coletivo
estipulou passos para concretizar o protótipo,
sendo eles: seleção de sensores, integração de
hardware, desenvolvimento de software e
validação.
A etapa de seleção de sensores conta com a
escolha cuidadosa de sensores especializados
para corrente, tensão, temperatura, potência,
fator de potência, consumo de energia, umidade
e vibração, garantindo precisão e confiabilidade
nas medições. Para tal finalidade, são levados
em consideração os parâmetros de medição, a
faixa de medição, ambiente de operação e
custo.
Em relação à parte de integração de
hardware, é ponderado o desenvolvimento de
circuitos de aquisição de dados e sua integração
com o sistema de controle do motor para
garantir uma coleta contínua e eficiente de
dados. O desenvolvimento de software dispõe
da implementação de algoritmos de
processamento de dados para análise em
tempo real, identificação de padrões anômalos e
geração de alerta de manutenção.
A validação é o estágio final para cada
modificação, onde são realizados testes para
adequação do protótipo e dos programas.
Ademais, está presente na etapa final do
trabalho, que é quando se executam extensivos
em condições operacionais diversas para
validar a eficácia do sistema de monitoramento,
assegurando sua robustez e precisão.
Prótotipo
Para a montagem do protótipo foi utilizado:
- 1 caixa de plástico
- 1 tábua de madeira
- 1 micro motor circulador de ar 1/25 bivolt
MM-20B Elgin
- 1 módulo sensor Dht11
- 1 sensor Ds18b20
- 1 sensor Sw-420
- 1 módulo relé SLA-05VDC-SL-C
- 1 módulo Pzem-004t
- 1 placa Uno R3
Figura 1 – Placa Uno R3.
Trabalho Integrador – Engenharia Elétrica
Fonte: Autor (2024).
Arduíno
O Arduino é uma plataforma de prototipagem
eletrônica de código aberto que consiste em
hardware e software projetados para facilitar a
criação de projetos interativos. Desenvolvido
com o intuito de ser acessível a iniciantes e
profissionais, o Arduino é amplamente utilizado
em diversas áreas, desde hobbyistas até
projetos industriais e educacionais.
O hardware do Arduino geralmente é
composto por uma placa com um
microcontrolador, entradas e saídas digitais e
analógicas, além de interfaces para conexão
com outros dispositivos. Já o software,
conhecido como Arduino IDE (Integrated
Development Environment), permite programar
o microcontrolador de forma simples e intuitiva,
utilizando uma linguagem baseada em C/C++.
Essa plataforma versátil e de baixo custo
possibilita a criação de uma variedade de
projetos, como sistemas de automação
residencial, robôs, sensores de monitoramento,
entre outros. Sua popularidade se deve à
facilidade de uso, à vasta comunidade de
suporte e à grande quantidade de bibliotecas
disponíveis para ampliar suas funcionalidades.
Python
A linguagem Python é uma linguagem de
programação de alto nível, interpretada, de
propósito geral e de código aberto, conhecida
pela sua simplicidade e legibilidade. Criada por
Guido van Rossum e lançada pela primeira vez
em 1991, Python tornou-se uma das linguagens
mais populares devido à sua facilidade de
aprendizado, sintaxe clara e vasta gama de
bibliotecas e frameworks disponíveis.
O Python é popularmente utilizado no
desenvolvimento de software devido à sua
facilidade de aprendizado, sintaxe clara e vasta
gama de bibliotecas e devido à sua capacidade
de lidar com uma variedade de tarefas, desde
tarefas simples até projetos complexos. Essas
características tornam o Python uma excelente
2
escolha para equipes de desenvolvimento circuito elétrico contra sobrecargas e curtos-
trabalharem em conjunto em projetos de circuitos. Para dimensionar o disjuntor, foi
software. calculado:
Além disso, Python é altamente versátil e
suporta diferentes estilos de programação, 127V / 220V
como programação orientada a objetos, 0,66A / 0,33A
programação funcional e programação
imperativa. Isso permite que os Fs =Fator de serviço
desenvolvedores escolham a abordagem que Is = Corrente nominal
melhor se adapte às necessidades específicas Im = Corrente máxima
de seus projetos de software.
IM= In x Fs
Resultados Para 127V = Im = 0,66 x 1,25 = 0,82A DJ 1A
Para 220V = Im = 0,33 x 1,25 = 0,41A DJ 1A
Os primeiros passos do projeto consistem no
grupo definindo qual o motor a ser empregado e Valores de Fs de 1,25 só são encontrados em
quais os tipos de parâmetros seriam utilizados, motores de pequenas potências.
para a partir disso escolher os sensores para a
medição dos parâmetros. Por fim, foi acordado Com isso, logo após dimensionado o disjuntor,
de se utilizar um motor de circulador e foram ocorreu a sua instalação, para enfim proteger os
estabelecidos sensores para a medição de elementos, como explicitado na Figura 2.
corrente, tensão, temperatura, potência, fator de
potência, energia gasta, umidade e vibração. Figura 2 – Dimensionamento do disjuntor.
O desenvolvimento do código no Arduino foi
um processo complicado, e inicialmente os
primeiros códigos não obtiveram os resultados
desejados. Entretanto, quem já precisou ou
montou algum código, sabe que é processo de
tentativa e erro, uma façanha que requer muita
paciência, atenção e dedicação.
Quando o grupo escolheu os sensores,
também haviam escolhido um sensor de
corrente e um sensor de tensão, porém durante
a realização dos testes, o código não fazia as
medições. Várias mudanças foram feitas e
mesmo assim não surgiu efeito, por
conseguinte, optaram por trocar os dois Fonte: Autor (2024).
sensores por um módulo Pzem-004t.
No momento de realizar os testes do código A princípio, o trabalho estava feito, mas o
do com o módulo Pzem-004t, notou-se que não circuito estava exposto, logo o grupo teve a
havia comunicação entre o sensor e o Arduino. iniciativa de proteger o circuito com uma
Tentaram inverter as conexões e verificar mais carcaça, colocando-o assim numa caixa de
muitas outras coisas que acabaram sem plástico, identificada na Figura 3.
sucesso algum. A partir disso, resolveram o
problema após setar o endereço o código Figura 3 – Montagem da carcaça do circuito e do
funcionou. suporte do motor.
Uma situação parecida aconteceu com o
sensor de temperatura do motor, quando
ocorrido a ativação do código não descrita a
medição de temperatura. Isso só se resolveu em
seguida da equipe fazer uma ligação em
paralelo com o cabo de alimentação e
informação do sensor com uma resistência.
Para manter a integridade dos componentes
do motor, apresentado no ANEXO I, era
primordial a inclusão do disjuntor, um dispositivo
eletromecânico projetado para proteger um

Trabalho Integrador – Engenharia Elétrica 3


Fonte: Autor (2024).
Por fim, foi criado um sistema de
monitoramento para ser utilizado em motores
elétricos, permitindo a verificação contínua do
desempenho e da condição dos motores, como
esclarecido nas Figuras 4 e 5. Informações dos
sensores são analisadas pelo código Arduino
apresentado no ANEXO II, que executa um
programa em Python trazido no ANEXO III,
capaz de identificar e gerar um alerta sobre
possíveis anomalias.
Figura 4 – Tela do supervisório.
Fonte: Autor (2024).
Figura 5 – Tela o gráfico do supervisório.
Fonte: Autor (2024).
Discussão
Trabalho Integrador – Engenharia Elétrica
Sobre o problema nos sensores de tensão e
corrente, foi visto posteriormente que era
necessário adicionar uma biblioteca específica
que poderia ter feito o programa funcionar. No
caso do Pzem, após ler o manual, acabaram
observando que devia estabelecer os limites do
endereço para haver a comunicação. Para o
sensor de temperatura, após lerem o datasheet
do mesmo, deu-se a notoriedade de colocar
uma resistência em paralelo com o fio de
alimentação do sensor e o fio de informação do
sensor.
Foram necessárias extensas pesquisas para
compreender de forma aprofundada a maneira
correta de ajustar as respostas dos sensores, de
modo que pudessem ser adequadamente
analisadas e tratadas pelo programa de
monitoramento. Essa investigação minuciosa foi
crucial para garantir a precisão e a eficácia do
processo de coleta e interpretação dos dados
dos sensores, contribuindo assim para a
integridade e confiabilidade do sistema de
monitoramento proposto.
A compreensão detalhada desses ajustes e
calibrações foi essencial para assegurar que as
informações capturadas pelos sensores seriam
interpretadas de forma precisa e significativa
pelo programa, possibilitando uma análise
precisa e a identificação precoce de quaisquer
potenciais problemas nos motores. Essa etapa
de pesquisa e refinamento é fundamental para o
sucesso e a eficácia do sistema de
monitoramento em sua totalidade.
Conclusão
Sobre o problema nos sensores de tensão e
corrente, foi visto posteriormente que era
necessário adicionar uma biblioteca específica
que poderia ter feito o programa funcionar. No
caso do Pzem, após ler o manual, acabaram
observando que devia estabelecer os limites do
endereço para haver a comunicação. Para o
sensor de temperatura, após lerem o datasheet
do mesmo, deu-se a notoriedade de colocar
uma resistência em paralelo com o fio de
alimentação do sensor e o fio de informação do
sensor.
Foram necessárias extensas pesquisas para
compreender de forma aprofundada a maneira
correta de ajustar as respostas dos sensores, de
modo que pudessem ser adequadamente
analisadas e tratadas pelo programa de
monitoramento. Essa investigação minuciosa foi
crucial para garantir a precisão e a eficácia do
4
processo de coleta e interpretação dos dados
dos sensores, contribuindo assim para a
integridade e confiabilidade do sistema de
monitoramento proposto.
A compreensão detalhada desses ajustes e
calibrações foi essencial para assegurar que as
informações capturadas pelos sensores seriam
interpretadas de forma precisa e significativa
pelo programa, possibilitando uma análise
precisa e a identificação precoce de quaisquer
potenciais problemas nos motores. Essa etapa
de pesquisa e refinamento é fundamental para o
sucesso e a eficácia do sistema de
monitoramento em sua totalidade.
Figura 6 – Tela do supervisório em
funcionamento.
Fonte: Autor (2024).
Figura 7 – Tela o gráfico do supervisório em
funcionamento.
Fonte: Autor (2024).
Referências
GARCEZ, Latif de Faria. Desenvolvimento de
um sistema de manutenção
Trabalho Integrador – Engenharia Elétrica
preditiva para motores elétricos. 2021.
Trabalho de conclusão de curso – Cusro de
Engenharia Mecânica, Universidade
Tecnológica Federal do Paraná, Londrina,
2021. Disponível
em:https://www.weg.net/institutional/BR/pt/digit
alsolutions/solutions/wegmotorscan. Acesso
em: 24 de fev. 2024.
MELO, Hugo da Costa Melo. Plano de
manutenção preditiva para motores
elétricos - Definição e implementação numa
indústria de pasta de papel. 2017. Relatório de
Estágio apresentado para a obtenção do grau
de Mestre - Curso de Engenharia Eletrotécnica
- Especialização em Sistemas de Energia,
Instituto Superior de Engenharia de Coimbra,
Coimbra, 2017. Disponível em:
https://comum.rcaap.pt/bitstream/10400.26/254
61/1/Hugo-Costa-Melo.pdf. Acesso em: 24 de
fev. 2024.
Monitoramento de Motores Elétricos: Monitorar,
Vibrações, corrente elétrica, Temperatura. In:
Monitoramento de Motores Elétricos. São
Paulo: WEG digital Solutions. Disponível
em:https://www.weg.net/institutional/BR/pt/digit
alsolutions/solutions/wegmotorscan. Acesso
em: 24 de fev. 2024.
PEDRO, Evandro J. P. et al. Sistema
eletrônico para monitorar a operação dos
motores elétricos de indução na indústria.
2020. Artigo do Grupo de Estudos - Curso de
Engenharia Elétrica, Centro Universitário
Academia - Uniacademia, Juiz de Fora, 2020.
Disponível em:
https://seer.uniacademia.edu.br/index.php/ANL/
article/download/2750/1830. Acesso em: 24 de
fev. 2024.
Agradecimentos
Agradeço a Deus, pela vida e pela
oportunidade de evoluir!
5
 Anexo I

Figura 8 – Motor utilizado.

Fonte: Siberiano Refrigeração (2024).

Micro motor circulador de ar 1/25 bivolt MM-20B Elgin

Motor monofásico de indução, tipo campo distorcido com mancais de bucha sintetizada auto-
compensadora e lubrificação permanente.

Diversas aplicações, especialmente em expositores e balcões frigoríficos, condensadores a ar e

evaporadores de ar forçado, unidades de refrigeração, bebedouros e refresqueiras.

Rotor do tipo gaiola, injetado em alumínio ultrapuro.

Hélice em plástico ABS de alta resistência.

Modelo compatível: MM-20B (Elgin).

Potência de saída: 1/25 – 12W – 16mHP. Alimentação elétrica: 115/220V (Bivolt).

Frequência: 60Hz. Corrente nominal: 0.66A (110V) / 0.33A (220V). Consumo: 55W.

Vazão de ar: 950m³/h. Rotação: 1.550rpm. Polaridade: 4 polos.

Grau de proteção: IP44. Classe de isolação: 130 °C. Diâmetro da hélice: 10″.

Ventilação: “Air Over”. Fluxo de ar: Exaustor.

– Acessórios inclusos: Hélice e Suporte.

– Cabo elétrico: 50cm.

– Bucha: Ferro sinterizada.

– Peso: 1,15 Kg.

Trabalho Integrador – Engenharia Elétrica 6

 Anexo II

#include <SoftwareSerial.h>

#include <PZEM004Tv30.h>

#include <DHT.h>

#include <OneWire.h>

#include <DallasTemperature.h>

// Define os pinos RX e TX para a comunicação serial com o PZEM004Tv30

#define PZEM_RX_PIN 10

#define PZEM_TX_PIN 11

PZEM004Tv30 pzem(PZEM_RX_PIN, PZEM_TX_PIN); // RX, TX

#define DHTPIN 13

#define DHTTYPE DHT11

#define motorPin 3 // Pino do motor (substitua pelo seu pino real)

#define Temp_motor 4 // Pino para o sensor DS18B20

#define vibracaoSensor A2 // Pino analógico para o sensor de vibração (P0191)

// Criar uma instância

DHT dht(DHTPIN, DHTTYPE);

OneWire oneWire(Temp_motor);

DallasTemperature sensors(&oneWire);

void setup() {

Serial.begin(9600);

// Configura o endereço do PZEM004Tv30 (padrão é 0x01)

pzem.setAddress(0x01);

dht.begin();

sensors.begin();

pinMode(motorPin, OUTPUT);

digitalWrite(motorPin, LOW); // Inicialmente, o motor está desligado

Trabalho Integrador – Engenharia Elétrica 7

void loop() {

// Leitura do sensor de temperatura DS18B20

sensors.requestTemperatures();

float Temp_motor1 = sensors.getTempCByIndex(0);

// Leitura do sensor de vibração (P0191)

int vibracao_V = analogRead(vibracaoSensor);

float umidade = dht.readHumidity();

float temp_ambi = dht.readTemperature();

// Ler os resultados da medição

float voltage = pzem.voltage();

float current = pzem.current();

float power = pzem.power();

float energy = pzem.energy();

float frequency = pzem.frequency();

float pf_pzem = pzem.pf();

// Calcula o fator de potência

float powerFactor = power / (voltage * current);

// Exibir os resultados

if (!isnan(umidade) && !isnan(temp_ambi)) {

// Envio dos dados pela porta serial

Serial.print("H:");

Serial.print(umidade);

Serial.print(",T:");

Serial.print(temp_ambi);

Serial.print(",C:");

Serial.print(current);

Serial.print(",V:");

Serial.print(voltage);

Serial.print(",T:");

Serial.print(Temp_motor1);

Trabalho Integrador – Engenharia Elétrica 8

 Serial.print(",V:");

Serial.print(vibracao_V);

Serial.print(",P:");

Serial.print(power);

Serial.print(",E:");

Serial.print(energy);

Serial.print(",F:");

Serial.println(pf_pzem);

//Serial.print(",F:");

//Serial.println(frequency);

// Verifica se há dados disponíveis na porta serial

while (Serial.available() > 0) {

char command = Serial.read();

if (command == '1') {

digitalWrite(motorPin, HIGH); // Liga o motor

} else if (command == '0') {

digitalWrite(motorPin, LOW); // Desliga o motor

delay(800); // Aguarda um segundo antes de ler novamente os dados

Trabalho Integrador – Engenharia Elétrica 9

 Anexo III

import serial
import tkinter as tk
from tkinter import font
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import os

ser = serial.Serial('COM3', 9600, timeout=1)

# Valores máximos permitidos

max_corrente = 1.0
max_tensao = 1.0
max_temp_ambiente = 1.0
max_umidade = 1.0
max_temp_motor = 1.0
max_vibracao = 1
min_tensao = 0.1
min_fator_potencia = 0.80
max_potencia = 100
max_energia = 0.0
max_fator_potencia = 0.90
# Valores mínimos permitidos
min_umidade = 0.0
min_tensao = 0.1
min_corrente = 0.0
min_temp_motor = 0.0
min_vibracao = 0
min_fator_potencia = 0.0
min_temp_ambiente = 0.0
min_potencia = 0.0
min_energia = 0.0

# Listas para armazenar dados ao longo do tempo

time_points = []
umidade_values = []
temp_ambiente_values = []
corrente_values = []
tensao_values = []
temp_motor_values = []
vibracao_values = []
potencia_values = []
energia_values = []
fator_potencia_values = []

def update_data():
try:
arduino_data = ser.readline().decode('utf-8', errors='replace').strip()
'''print(f"Arduino Data: {arduino_data}")'''
if arduino_data:
data_parts = arduino_data.split(',')
if len(data_parts) == 9: # Ajustar conforme o número total de valores enviados pelo Arduino
umidade = float(data_parts[0].split(':')[1])
temp_ambiente_part = data_parts[1].split(':')[1].rstrip('°C')

Trabalho Integrador – Engenharia Elétrica 1

0
 temp_ambiente = float(temp_ambiente_part) if temp_ambiente_part else 0.0
corrente = float(data_parts[2].split(':')[1])
tensao = float(data_parts[3].split(':')[1])
temp_motor = float(data_parts[4].split(':')[1])
vibracao = int(data_parts[5].split(':')[1])
potencia = float(data_parts[6].split(':')[1])
energia = float(data_parts[7].split(':')[1])
fator_potencia = float(data_parts[8].split(':')[1])

# Atualiza as listas com os novos dados

time_points.append(len(time_points) + 1)
umidade_values.append(umidade)
temp_ambiente_values.append(temp_ambiente)
corrente_values.append(corrente)
tensao_values.append(tensao)
temp_motor_values.append(temp_motor)
vibracao_values.append(vibracao)
potencia_values.append(potencia)
energia_values.append(energia)
fator_potencia_values.append(fator_potencia)

# Atualiza os rótulos no layout gráfico

update_label(umidade_label, umidade, max_umidade, min_umidade) # Verifique se
min_umidade é definido em algum lugar
update_label(temp_ambiente_label, temp_ambiente, max_temp_ambiente,
min_temp_ambiente) # Verifique se min_temp_ambiente é definido em algum lugar
update_label(corrente_label, corrente, max_corrente, min_corrente) # Verifique se
min_corrente é definido em algum lugar
update_label(tensao_label, tensao, max_tensao, min_tensao) # Verifique se min_tensao é
definido em algum lugar
update_label(temp_motor_label, temp_motor, max_temp_motor, min_temp_motor) #
Verifique se min_temp_motor é definido em algum lugar
update_label(vibracao_label, vibracao, max_vibracao, min_vibracao) # Verifique se
min_vibracao é definido em algum lugar
update_label(potencia_label, potencia, max_potencia, min_potencia) # Verifique se
min_potencia é definido em algum lugar
update_label(energia_label, energia, max_energia, min_energia) # Verifique se
min_energia é definido em algum lugar
update_label(fator_potencia_label, fator_potencia, max_fator_potencia, min_fator_potencia)
# Verifique se min_fator_potencia é definido em algum lugar

# Salva os dados a cada atualização

save_data_to_csv()

except UnicodeDecodeError as e:
print(f"Erro de decodificação: {e}")

root.after(1000, update_data)

def update_label(label, value, max_value, min_value):

new_text = f"{label.cget('text').split('\n')[0]}\n{value}"
label.config(text=new_text)

# Verifica se o valor ultrapassa os limites

if max_value > 0 and (value > max_value or value < min_value):
label.config(fg="red") # Define a cor do texto para vermelho
else:

Trabalho Integrador – Engenharia Elétrica 1

1
 label.config(fg="black") # Redefine a cor do texto para preto

def send_command(command):
ser.write(command.encode('utf-8'))

def set_limits(max_corrente_value, max_tensao_value, max_temp_ambiente_value,

max_umidade_value, max_temp_motor_value, max_vibracao_value, min_fator_potencia_value,
min_tensao_value):
global max_corrente, max_tensao, max_temp_ambiente, max_umidade, max_temp_motor,
max_vibracao, min_fator_potencia, min_tensao

try:
max_corrente = float(max_corrente_value.get())
max_tensao = float(max_tensao_value.get())
max_temp_ambiente = float(max_temp_ambiente_value.get())
max_umidade = float(max_umidade_value.get())
max_temp_motor = float(max_temp_motor_value.get())
max_vibracao = float(max_vibracao_value.get())
min_fator_potencia = float(min_fator_potencia_value.get())
min_tensao = float(min_tensao_value.get()) # Atualiza o valor de min_tensao
except ValueError:
# Caso haja um erro de conversão, não altera os valores
pass

# Fecha a janela de limites

limits_window.destroy()

def open_limits_window():
# Função chamada quando o botão "Configurar Limites" é pressionado
global limits_window

# Cria uma nova janela de limites

limits_window = tk.Toplevel(root)
limits_window.title("Configurar Limites")

max_corrente_label = tk.Label(limits_window, text="Corrente Máxima:", font=("Helvetica", 12))

max_corrente_label.pack()

max_corrente_entry = tk.Entry(limits_window, font=("Helvetica", 12))

max_corrente_entry.insert(0, max_corrente)
max_corrente_entry.pack()

max_tensao_label = tk.Label(limits_window, text="Tensão Máxima:", font=("Helvetica", 12))

max_tensao_label.pack()

max_tensao_entry = tk.Entry(limits_window, font=("Helvetica", 12))

max_tensao_entry.insert(0, max_tensao)
max_tensao_entry.pack()

min_tensao_label = tk.Label(limits_window, text="Tensão Mínima:", font=("Helvetica", 12))

min_tensao_label.pack()

min_tensao_entry = tk.Entry(limits_window, font=("Helvetica", 12))

min_tensao_entry.insert(0, min_tensao)
min_tensao_entry.pack()

Trabalho Integrador – Engenharia Elétrica 1

2
 max_temp_ambiente_label = tk.Label(limits_window, text="Temperatura Máxima:",
font=("Helvetica", 12))
max_temp_ambiente_label.pack()

max_temp_ambiente_entry = tk.Entry(limits_window, font=("Helvetica", 12))

max_temp_ambiente_entry.insert(0, max_temp_ambiente)
max_temp_ambiente_entry.pack()

max_umidade_label = tk.Label(limits_window, text="Umidade Máxima:", font=("Helvetica", 12))

max_umidade_label.pack()

max_umidade_entry = tk.Entry(limits_window, font=("Helvetica", 12))

max_umidade_entry.insert(0, max_umidade)
max_umidade_entry.pack()

max_temp_motor_label = tk.Label(limits_window, text="Temperatura Motor Máxima:",

font=("Helvetica", 12))
max_temp_motor_label.pack()

max_temp_motor_entry = tk.Entry(limits_window, font=("Helvetica", 12))

max_temp_motor_entry.insert(0, max_temp_motor)
max_temp_motor_entry.pack()

max_vibracao_label = tk.Label(limits_window, text="Vibração Máxima:", font=("Helvetica", 12))

max_vibracao_label.pack()

max_vibracao_entry = tk.Entry(limits_window, font=("Helvetica", 12))

max_vibracao_entry.insert(0, max_vibracao)
max_vibracao_entry.pack()

min_fator_potencia_label = tk.Label(limits_window, text="Fator de Potência Mínimo:",

font=("Helvetica", 12))
min_fator_potencia_label.pack()

min_fator_potencia_entry = tk.Entry(limits_window, font=("Helvetica", 12))

min_fator_potencia_entry.insert(0, min_fator_potencia)
min_fator_potencia_entry.pack()

# Botão "OK" que chama a função set_limits

ok_button = tk.Button(limits_window, text="OK", command=lambda: set_limits(
max_corrente_entry,
max_tensao_entry,
max_temp_ambiente_entry,
max_umidade_entry,
max_temp_motor_entry,
max_vibracao_entry,
min_fator_potencia_entry,
min_tensao_entry # Adicione min_tensao_entry aqui
), font=("Helvetica", 12))
ok_button.pack() # Certifique-se de que esta linha esteja corretamente alinhada
def plot_graphs():
fig, axes = plt.subplots(nrows=3, ncols=2, figsize=(12, 8))
grafico = axes.flatten()

grafico[0].plot(time_points, umidade_values, label='Umidade')

Trabalho Integrador – Engenharia Elétrica 1

3
 grafico[0].axhline(y=max_umidade, color='r', linestyle='--', label='Limite Máximo')
grafico[0].set_xlabel('Tempo')
grafico[0].set_ylabel('Umidade')
grafico[0].legend()

grafico[1].plot(time_points, temp_ambiente_values, label='Temperatura')

grafico[1].axhline(y=max_temp_ambiente, color='r', linestyle='--', label='Limite Máximo')
grafico[1].set_xlabel('Tempo')
grafico[1].set_ylabel('Temperatura')
grafico[1].legend()

grafico[2].plot(time_points, corrente_values, label='Atual')

grafico[2].axhline(y=max_corrente, color='r', linestyle='--', label='Limite Máximo')
grafico[2].set_xlabel('Tempo')
grafico[2].set_ylabel('Corrente')
grafico[2].legend()

grafico[3].plot(time_points, tensao_values, label='Tensão')

grafico[3].axhline(y=max_tensao, color='r', linestyle='--', label='Limite Máximo')
grafico[3].axhline(y=min_tensao, color='g', linestyle='--', label='Limite Mínimo')
grafico[3].set_xlabel('Tempo')
grafico[3].set_ylabel('Tensão')
grafico[3].legend()

grafico[4].plot(time_points, temp_motor_values, label='Temperatura Motor')

grafico[4].axhline(y=max_temp_motor, color='r', linestyle='--', label='Limite Máximo')
grafico[4].set_xlabel('Tempo')
grafico[4].set_ylabel('Temperatura Motor')
grafico[4].legend()

grafico[5].plot(time_points, vibracao_values, label='Vibração')

grafico[5].axhline(y=max_vibracao, color='r', linestyle='--', label='Limite Máximo')
grafico[5].set_xlabel('Tempo')
grafico[5].set_ylabel('Vibração')
grafico[5].legend()

plt.tight_layout()
plt.show()

def save_data_to_csv():
with open('sensor_data.csv', 'w') as file:
file.write("Time, umidade, temp_ambiente, Corrente , Tensao, temp_motor, vibracao\n")
for i in range(len(time_points)):
file.write(f"{time_points[i]}, {umidade_values[i]}, {temp_ambiente_values[i]},
{corrente_values[i]}, {tensao_values[i]}, {temp_motor_values[i]}, {vibracao_values[i]}\n")

def delete_all_data():
global time_points, umidade_values, temp_ambiente_values, corrente_values, tensao_values,
temp_motor_values, vibracao_values
time_points = []
umidade_values = []
temp_ambiente_values = []
corrente_values = []
tensao_values = []
temp_motor_values = []
vibracao_values = []

Trabalho Integrador – Engenharia Elétrica 1

4
 # Excluir o arquivo CSV
try:
os.remove('sensor_data.csv')
except FileNotFoundError:
pass

# Configuração da interface gráfica

root = tk.Tk()
root.title("Leitura de Sensores")

title_label = tk.Label(root, text="Sistema de Monitoramento de Motores Elétricos", font=("Helvetica",

16))
title_label.pack(side=tk.TOP, pady=10)

screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()

window_width = int(0.8 * screen_width)

window_height = int(0.6 * screen_height)

root.geometry(f"{window_width}x{window_height}+{int((screen_width -
window_width)/2)}+{int((screen_height - window_height)/2)}")

label_font = font.Font(size=18)

# Frames para os botões

buttons_frame = tk.Frame(root)
buttons_frame.pack(side=tk.TOP, padx=10, pady=10)

motor_on_button = tk.Button(buttons_frame, text="Ligar Motor", command=lambda:

send_command('1'), font=label_font)
motor_on_button.pack(side=tk.LEFT, padx=20, pady=10)

motor_off_button = tk.Button(buttons_frame, text="Desligar Motor", command=lambda:

send_command('0'), font=label_font)
motor_off_button.pack(side=tk.LEFT, padx=20, pady=20)

set_limits_button = tk.Button(buttons_frame, text="Configurar Limites",

command=open_limits_window, font=label_font)
set_limits_button.pack(side=tk.LEFT, padx=20, pady=20)

plot_button = tk.Button(buttons_frame, text="Gráficos", command=plot_graphs, font=label_font)

plot_button.pack(side=tk.LEFT, padx=20, pady=20)

delete_data_button = tk.Button(buttons_frame, text="Limpar Dados Salvos",

command=delete_all_data, font=label_font)
delete_data_button.pack(side=tk.LEFT, padx=20, pady=20)

# Frames para as medições

measurements_frame = tk.Frame(root)
measurements_frame.pack(side=tk.TOP, padx=10, pady=10)

umidade_frame = tk.Frame(measurements_frame, bd=2, relief=tk.GROOVE)

umidade_frame.grid(row=0, column=0, padx=30, pady=20)

umidade_label = tk.Label(umidade_frame, text="Umidade \n", font=label_font)

umidade_label.pack()

Trabalho Integrador – Engenharia Elétrica 1

5
temp_ambiente_frame = tk.Frame(measurements_frame, bd=2, relief=tk.GROOVE)
temp_ambiente_frame.grid(row=0, column=1, padx=30, pady=20)

temp_ambiente_label = tk.Label(temp_ambiente_frame, text="Temperatura Ambiente [ºC]\n",

font=label_font)
temp_ambiente_label.pack()

corrente_frame = tk.Frame(measurements_frame, bd=2, relief=tk.GROOVE)

corrente_frame.grid(row=0, column=2, padx=30, pady=20)

corrente_label = tk.Label(corrente_frame, text="Corrente [A]\n", font=label_font)

corrente_label.pack()

tensao_frame = tk.Frame(measurements_frame, bd=2, relief=tk.GROOVE)

tensao_frame.grid(row=0, column=3, padx=30, pady=20)

tensao_label = tk.Label(tensao_frame, text="Tensão [V]\n", font=label_font)

tensao_label.pack()

temp_motor_frame = tk.Frame(measurements_frame, bd=2, relief=tk.GROOVE)

temp_motor_frame.grid(row=1, column=0, padx=30, pady=20)

temp_motor_label = tk.Label(temp_motor_frame, text="Temperatura Motor [ºC]\n", font=label_font)

temp_motor_label.pack()

vibracao_frame = tk.Frame(measurements_frame, bd=2, relief=tk.GROOVE)

vibracao_frame.grid(row=1, column=1, padx=30, pady=20)

vibracao_label = tk.Label(vibracao_frame, text="Vibração Motor\n", font=label_font)

vibracao_label.pack()

potencia_frame = tk.Frame(measurements_frame, bd=2, relief=tk.GROOVE)

potencia_frame.grid(row=1, column=2, padx=30, pady=20)

potencia_label = tk.Label(potencia_frame, text="Potência [W]\n", font=label_font)

potencia_label.pack()

energia_frame = tk.Frame(measurements_frame, bd=2, relief=tk.GROOVE)

energia_frame.grid(row=1, column=3, padx=30, pady=20)

energia_label = tk.Label(energia_frame, text="Energia\n", font=label_font)

energia_label.pack()

fator_potencia_frame = tk.Frame(measurements_frame, bd=2, relief=tk.GROOVE)

fator_potencia_frame.grid(row=2, column=0, padx=30, pady=20, columnspan=4)

fator_potencia_label = tk.Label(fator_potencia_frame, text="Fator de Potência\n", font=label_font)

fator_potencia_label.pack()

update_data()

root.mainloop()

root.mainloop()

Trabalho Integrador – Engenharia Elétrica 1

6