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

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

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. Fonte: Autor (2024).
A etapa de seleção de sensores conta com a
escolha cuidadosa de sensores especializados Arduíno
para corrente, tensão, temperatura, potência, O Arduino é uma plataforma de prototipagem
fator de potência, consumo de energia, umidade eletrônica de código aberto que consiste em
e vibração, garantindo precisão e confiabilidade hardware e software projetados para facilitar a
nas medições. Para tal finalidade, são levados criação de projetos interativos. Desenvolvido
em consideração os parâmetros de medição, a com o intuito de ser acessível a iniciantes e
faixa de medição, ambiente de operação e profissionais, o Arduino é amplamente utilizado
custo. em diversas áreas, desde hobbyistas até
Em relação à parte de integração de projetos industriais e educacionais.
hardware, é ponderado o desenvolvimento de O hardware do Arduino geralmente é
circuitos de aquisição de dados e sua integração composto por uma placa com um
com o sistema de controle do motor para microcontrolador, entradas e saídas digitais e
garantir uma coleta contínua e eficiente de analógicas, além de interfaces para conexão
dados. O desenvolvimento de software dispõe com outros dispositivos. Já o software,
da implementação de algoritmos de conhecido como Arduino IDE (Integrated
processamento de dados para análise em Development Environment), permite programar
tempo real, identificação de padrões anômalos e o microcontrolador de forma simples e intuitiva,
geração de alerta de manutenção. utilizando uma linguagem baseada em C/C++.
A validação é o estágio final para cada Essa plataforma versátil e de baixo custo
modificação, onde são realizados testes para possibilita a criação de uma variedade de
adequação do protótipo e dos programas. projetos, como sistemas de automação
Ademais, está presente na etapa final do residencial, robôs, sensores de monitoramento,
trabalho, que é quando se executam extensivos entre outros. Sua popularidade se deve à
em condições operacionais diversas para facilidade de uso, à vasta comunidade de
validar a eficácia do sistema de monitoramento, suporte e à grande quantidade de bibliotecas
assegurando sua robustez e precisão. disponíveis para ampliar suas funcionalidades.

Prótotipo Python
Para a montagem do protótipo foi utilizado: A linguagem Python é uma linguagem de
- 1 caixa de plástico programação de alto nível, interpretada, de
- 1 tábua de madeira propósito geral e de código aberto, conhecida
- 1 micro motor circulador de ar 1/25 bivolt pela sua simplicidade e legibilidade. Criada por
MM-20B Elgin Guido van Rossum e lançada pela primeira vez
- 1 módulo sensor Dht11 em 1991, Python tornou-se uma das linguagens
- 1 sensor Ds18b20 mais populares devido à sua facilidade de
- 1 sensor Sw-420 aprendizado, sintaxe clara e vasta gama de
- 1 módulo relé SLA-05VDC-SL-C bibliotecas e frameworks disponíveis.
- 1 módulo Pzem-004t O Python é popularmente utilizado no
- 1 placa Uno R3 desenvolvimento de software devido à sua
facilidade de aprendizado, sintaxe clara e vasta
Figura 1 – Placa Uno R3. 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

Trabalho Integrador – Engenharia Elétrica 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

 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
Fonte: Autor (2024). 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
Por fim, foi criado um sistema de dos sensores, contribuindo assim para a
monitoramento para ser utilizado em motores integridade e confiabilidade do sistema de
elétricos, permitindo a verificação contínua do monitoramento proposto.
desempenho e da condição dos motores, como A compreensão detalhada desses ajustes e
esclarecido nas Figuras 4 e 5. Informações dos calibrações foi essencial para assegurar que as
sensores são analisadas pelo código Arduino informações capturadas pelos sensores seriam
apresentado no ANEXO II, que executa um interpretadas de forma precisa e significativa
programa em Python trazido no ANEXO III, pelo programa, possibilitando uma análise
capaz de identificar e gerar um alerta sobre precisa e a identificação precoce de quaisquer
possíveis anomalias. potenciais problemas nos motores. Essa etapa
de pesquisa e refinamento é fundamental para o
Figura 4 – Tela do supervisório. 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
Fonte: Autor (2024). que poderia ter feito o programa funcionar. No
caso do Pzem, após ler o manual, acabaram
Figura 5 – Tela o gráfico do supervisório. 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
Fonte: Autor (2024). analisadas e tratadas pelo programa de
monitoramento. Essa investigação minuciosa foi
Discussão crucial para garantir a precisão e a eficácia do

Trabalho Integrador – Engenharia Elétrica 4

processo de coleta e interpretação dos dados preditiva para motores elétricos. 2021.
dos sensores, contribuindo assim para a Trabalho de conclusão de curso – Cusro de
integridade e confiabilidade do sistema de Engenharia Mecânica, Universidade
monitoramento proposto. Tecnológica Federal do Paraná, Londrina,
A compreensão detalhada desses ajustes e 2021. Disponível
calibrações foi essencial para assegurar que as em:https://www.weg.net/institutional/BR/pt/digit
informações capturadas pelos sensores seriam alsolutions/solutions/wegmotorscan. Acesso
interpretadas de forma precisa e significativa em: 24 de fev. 2024.
pelo programa, possibilitando uma análise
MELO, Hugo da Costa Melo. Plano de
precisa e a identificação precoce de quaisquer
manutenção preditiva para motores
potenciais problemas nos motores. Essa etapa
elétricos - Definição e implementação numa
de pesquisa e refinamento é fundamental para o
indústria de pasta de papel. 2017. Relatório de
sucesso e a eficácia do sistema de
Estágio apresentado para a obtenção do grau
monitoramento em sua totalidade.
de Mestre - Curso de Engenharia Eletrotécnica
Figura 6 – Tela do supervisório em - Especialização em Sistemas de Energia,
funcionamento. 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
Fonte: Autor (2024).
alsolutions/solutions/wegmotorscan. Acesso
em: 24 de fev. 2024.
Figura 7 – Tela o gráfico do supervisório em
funcionamento. 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.
Fonte: Autor (2024).
Agradecimentos
Referências
Agradeço a Deus, pela vida e pela
oportunidade de evoluir!
GARCEZ, Latif de Faria. Desenvolvimento de
um sistema de manutenção

Trabalho Integrador – Engenharia Elétrica 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