Analise do Material
3 de junho de 2022Atividade destinada ao curso de Pos graduação UNINOVE.
Artigo
Article
Fuzzy-Based Statistical Feature Extraction for
Detecting Broken Rotor Bars in Line-Fed and
Inverter-Fed Induction Motors
Cleber Gustavo Dias 1,* , Luiz Carlos da Silva 1 and Ivan Eduardo Chabu 2
Analise do material
Objetivo do material
Identificar disturbios na barra de rotor através de sensoriamento.
São os sensores Efeito Hall (efeito de campo magnético) o mesmo utilizado em estradas.
Permitindo identificar a existência, mas o comprometimento da barra.
No método aplica-se um tenção de 7,5KW alimentada por um inversor
Introdução
Apresenta uma visão da necessidade, bem como do ambiente industrial aplicado. Onde máquinas são movidas por motores elétricos.
Ele aponta alguns problemas:
- Rolamento dos motores
- gaiola do rotor
- Mancais
Estima-se que paradas não previstas , geram uma perda de receita de US$2,5 a US$4.0 milhões.
Falhas possíveis
- malha fechada
- vazamento detectado por escorregamento muito baixo,componente da banda lateral esquerda
Tempo de leitura
aproximadamente 100s, ou seja 1 minuto e meio de leituras amostrais.
Metodologias e propostas de analise
Baseadas em Transformada wavelet Discreta (DWT) e Transformada de Fourier de Tempo Curto (STFT).
Falhas em máquinas rotativas,
como abordagens no domínio do tempo e no domínio da frequência, bem como o uso de KNN, SVM e Fuzzy
Classificadores c-Means, entre outros.
Este artigo apresenta o uso de um sistema de inferência fuzzy (FIS) para extrair as características de um sensor Hall sinal, instalado dentro do motor, de acordo com a condição do rotor.
Resultados de tradução
(i) Não é necessário estimar o escorregamento do rotor, conforme exigido pelo método MCSA e outras técnicas
(relacionado à indicação de FN);
(ii) É possível detectar barras quebradas durante a variação de carga (relacionada à indicação FN);
(iii) É possível detectar barras quebradas durante oscilações de carga de baixa frequência (relacionadas à indicação de FP);
(iv) É possível classificar a gravidade das falhas do rotor;
(v) É possível detectar barras de rotor rompidas para motor funcionando em baixo escorregamento (relacionado à indicação FN);
e
(vi) O método permite a detecção de falhas do rotor para motores alimentados por um inversor e também alimentados por
fonte de energia.
A presente abordagem foi validada usando resultados de simulação de dois IMs (1200 kW e
7,5 kW) e foram realizados testes experimentais utilizando um motor de indução de 7,5 kW, 220 V e
38 barras de rotor, alimentadas por uma alimentação senoidal e por um inversor. A metodologia e os resultados são
apresentados nas subseções a seguir.
Artigo 2
Developing IoT Sensing System for
Construction-Induced Vibration Monitoring and
Impact Assessment
Neste artigo, a justificativa do trabalho se baseia no crescimento vertical , onde analise de vibrações tem ligação direta com processos construtivos. Garantindo qualidade e segurança.
O projeto justifica seu uso, e apresenta um sistema robusto porem de baixo custo baseado em solução raspberry, bluetooth e 4G
Sensores IoT
Developing IoT Sensing System for
Construction-Induced Vibration Monitoring and
Impact Assessment
Qiuhan Meng and Songye Zhu *
Department of Civil and Environmental Engineering, The Hong Kong Polytechnic University,
Hong Kong, China; qiuhan.m.meng@connect.polyu.hk
- Correspondence: songye.zhu@polyu.edu.hk; Tel.: +852-34003964
Utilizando um raspberry pi, conectado a um dispositivo 4G ligado ao sensor acelerometro pela porta GPIO, conforme figura abaixo:
Tabela de resolução do equipamento LSM9DS1
A comunicação e internet
Se dá através de dong USB 4G.
Velocidades de conexão variam, podendo chegar
Fornecimento de energia
O consume do RASPBERRY é baixo, e estima-se que um painel de 50W, ligado a uma bateria de 20Ah com 12V possa fornecer 28h de energia ininterrupta, mesmo sem recarga, e que o painel de 50W possa recarregar em 7H. Sendo mais que suficiente para sua alimentação.
Software
O Software necessário precisa ler o GPIO , lendo o dispositivo I2C, gravando em um arquivo CSV.
Conforme fluxograma
A sincronização de tempo se dá pelo serviço de NTP.
Como os relogios são sincronizados pelo mesmo servidor ntp, os times são bem precisos, com uma diferença estimada em 10ms
Armazenamento na nuvem
Se dá através de um servidor em nuvem, através de aplicação conforme exemplo a seguir
Comparado com um equipamento industrial, o uso do raspberry, teve uma diferença de 3% em média menor, nos valores amostrados, mostrando uma confiabilidade em diferentes tipos de frequencia.
Resumo e Discussão
Este estudo apresenta o projeto, desenvolvimento e validação de um sistema de sensoriamento IoT sem fio para
monitoramento de vibração induzida pela construção em tempo real e avaliação de impacto. O hardware do
O sistema de detecção IoT desenvolvido consiste na placa Raspberry Pi, acelerômetro MEMS, Internet 4G
dongle e bateria solar. O Raspberry Pi é usado para coletar e analisar sinais digitais medidos por
o acelerômetro MEMS. Processamento de sinal local, incluindo filtro de dados, integração e avaliação de
níveis de vibração em tempo real em relação ao PPV, velocidade RMS na banda de 1/3 de oitava e aceleração RMS
Sensores 2020, 20, 6120 21 de 23
em banda de 1/3 de oitava, são realizados no Raspberry Pi. Os dados brutos e processados, bem como os
os resultados analisados são transmitidos para o banco de dados MySQL na nuvem pública através do celular 4G
rede em tempo hábil. Painéis solares com bateria recarregável são usados como fonte de energia contínua
fornecer. O software de operação e o mecanismo de sincronização de tempo NTP são desenvolvidos de acordo.
As funções de banco de dados e alarme são implementadas no sistema em nuvem. Além disso, uma página da web
interface do usuário é desenvolvida para exibir resultados de medição em tempo real e sinais de alarme, que podem
ser acessado remotamente a partir do computador autorizado ou dispositivos móveis via Internet. O saliente
Os recursos do sistema de detecção de vibração IoT incluem: (1) tamanho pequeno e sensor sem fio autônomo
nós que permitem fácil instalação sem qualquer trabalho de cabeamento, (2) baixos custos de hardware e baixo consumo de energia
consumo, (3) nós de sensores independentes evitando rede hierárquica de sensores, (4) dados confiáveis
transmissão sem perda de dados, (5) sincronização de tempo NTP permitindo amostragem de dados de alta precisão,
e (6) processamento de dados em tempo real, avaliação de vibração e capacidade de alarme.
A precisão do acelerômetro MEMS selecionado (LSM9DS1) foi verificada através do
comparação com o acelerômetro tradicionalmente com fio nos experimentos de laboratório. Além disso, a IoT
sistema de detecção de vibração foi testado em um local de constrição real em Hong Kong com estaca-prancha em andamento
trabalho de construção. Os resultados experimentais de laboratório e de campo indicaram que o
O sistema de detecção IoT pode medir vibrações induzidas pela construção com precisão satisfatória em ambos
domínio do tempo e da frequência. O poder computacional do Raspberry Pi e da nuvem permite que o
cálculo em tempo real de diferentes indicadores de vibração e avaliar o impacto da vibração comparando
vários limites de vibração pré-especificados. Este sistema de detecção de vibração IoT será implementado em breve
em outro canteiro de obras em Hong Kong para monitoramento de impacto de vibração de construção a longo prazo
e avaliação.
Notavelmente, o Raspberry Pi é uma plataforma de código aberto que permite conexões com vários tipos de
sensores com portas compatíveis. Portanto, o sistema de detecção IoT desenvolvido pode ser convenientemente estendido
a outras funções de monitoramento, como microfones MEMS para medição de ruído, temperatura e
sensores de umidade para monitoramento ambiental, sensores ultrassônicos para detecção de danos e
sensores de vibração de sensibilidade, se necessário.
Contribuições dos autores: Conceituação, metodologia, software, validação, investigação, curadoria de dados e
redação—preparação do rascunho original: Q.M.; Conceituação, redação – revisão e edição, supervisão, projeto
administração e aquisição de financiamento: S.Z. Todos os autores leram e concordaram com a versão publicada de
o manuscrito.
Financiamento: Esta pesquisa foi financiada pelo Conselho da Indústria da Construção de Hong Kong (número de concessão: CICR/03/18)
e a Universidade Politécnica de Hong Kong (número da concessão: Projeto No. ZE1F).
Conflitos de interesse: Os autores declaram não haver conflito
de interesse.
Minhas referencias
http://maurinsoft.com.br/index.php/2022/05/27/integrando-python-com-php/
http://maurinsoft.com.br/index.php/2022/02/04/mysql-com-c-lazarus-python-php-r-parte-3/
http://maurinsoft.com.br/index.php/2022/01/31/mysql-com-c-lazarus-python-php-r-parte-1/
Objetivo – Analise do Artigo
O projeto visa estabelecer a base de um hardware suficiente para captura de vibraçoes, propiciando a captura e envio das informações para um servidor em nuvem.
Entendendo como a captura é realizada, através de um raspberry PI, que é um equipamento fornecido por uma organização sem fins lucrativos A Fundação Raspberry PI www.raspberrypi.org [https://pt.wikipedia.org/wiki/Raspberry_Pi_Foundation].
Na qual provê alem do equipamento, tambem um sistema operacional RASPIAN (linux like), no qual permite o desenvolvimento de diversos projetos embarcados com grande flexibilidade e robustes.
Instalação do Serviço de NTP
Uma das primeiras coisas que são feitas no equipamento, é o cuidado com a sincronização dos tempos.
A sincronização dos tempos é feita através de um serviço de NTP, que é Network Time Protocol [https://ntp.br/]. O NTP garante sincronização dos tempos baseados em servidores de tempo ultra precisos, espalhados pelo mundo. No caso usaremos o servidor a.st1.ntp.br.
Este servidor foi estabelecido pois tem tempo de resposta entre 12.ms1 e 12.9ms.
Instalando o SSH
Após a instalação do Servidor de NTP, será necessário instalar um serviço de manutenção de ssh, para propiciar a conexão remota nos equipamentos. O procedimento para realização pode ser visto no link [https://roboticsbackend.com/enable-ssh-on-raspberry-pi-raspbian/]
Após a instalação de um serviço é necessário o acesso a internet.
No Raspberry PI, isso é feito de duas formas, no nosso caso usaremos o processo de conexão via WIFI, que permite conectar através de uma rede. Lendo as informações de acesso. O procedimento de configuração de um wifi, pode ser visto conforme segue [https://pplware.sapo.pt/linux/tutorial-raspberry-pi-configurar-wireless-via-linha-de-comandos/]
Instalando um servidor web
A instalação do equipamento, agora será necessário permitir configurar um serviço de monitoramento web, para que possamos conectar aparelhos como celular ou tablets a fim de obter leituras do dispositivo. Para tanto usaremos um servidor APACHE/PHP, realizando o procedimento de instalação conforme o apresentado. [https://randomnerdtutorials.com/raspberry-pi-apache-mysql-php-lamp-server/]
Para analise de dados usaremos o python para realizar a leitura dos dados amostrados.
Para tanto usaremos um processo de integração direto, entre o PHP/Python, conforme apresentado no link abaixo:
[https://maurinsoft.com.br/index.php/2022/05/27/integrando-python-com-php/]
Conexões com Hardware
Depois de montado o sistema operacional e criado uma versão funcional do linux com os requisitos minimos necessários para a manutenção, iremos suprir o hardware necessário.
As conexões com o raspberry são realizadas conforme figura abaixo, gentilmente fornecida pelo site:
Análise de acelerômetro, giroscópio e magnetômetro com Raspberry Pi Parte I: leituras básicas
O procedimento de criação bem como captura das informações tambem estão disponíveis no site acima referenciado.
Ficando apenas de referencia o codigo
# deve ser salvo na pasta local com o nome "mpu9250_i2c.py"
# será usado como controlador I2C e porto de função para o projeto
# consulte o datasheet e registre o mapa para obter uma explicação completa
import smbus,time
def MPU6050_start():
# alterar a taxa de amostragem (estabilidade)
samp_rate_div = 0 # sample rate = 8 kHz/(1+samp_rate_div)
bus.write_byte_data(MPU6050_ADDR, SMPLRT_DIV, samp_rate_div)
time.sleep(0.1)
# redefinir todos os sensores
bus.write_byte_data(MPU6050_ADDR,PWR_MGMT_1,0x00)
time.sleep(0.1)
# gerenciamento de energia e configurações de cristal
bus.write_byte_data(MPU6050_ADDR, PWR_MGMT_1, 0x01)
time.sleep(0.1)
#Write to Configuration register
bus.write_byte_data(MPU6050_ADDR, CONFIG, 0)
time.sleep(0.1)
#Escrever no registro de configuração do Gyro
gyro_config_sel = [0b00000,0b010000,0b10000,0b11000] # byte registers
gyro_config_vals = [250.0,500.0,1000.0,2000.0] # degrees/sec
gyro_indx = 0
bus.write_byte_data(MPU6050_ADDR, GYRO_CONFIG, int(gyro_config_sel[gyro_indx]))
time.sleep(0.1)
#Gravar no registro de configuração do Accel
accel_config_sel = [0b00000,0b01000,0b10000,0b11000] # byte registers
accel_config_vals = [2.0,4.0,8.0,16.0] # g (g = 9.81 m/s^2)
accel_indx = 0
bus.write_byte_data(MPU6050_ADDR, ACCEL_CONFIG, int(accel_config_sel[accel_indx]))
time.sleep(0.1)
# registro de interrupção (relacionado ao estouro de dados [FIFO])
bus.write_byte_data(MPU6050_ADDR, INT_ENABLE, 1)
time.sleep(0.1)
return gyro_config_vals[gyro_indx],accel_config_vals[accel_indx]
def read_raw_bits(register):
#ler valores de aceleração e giroscópio
high = bus.read_byte_data(MPU6050_ADDR, register)
low = bus.read_byte_data(MPU6050_ADDR, register+1)
# combinado alto e baixo para valor de bit sem sinal
value = ((high << 8) | low)
# converter para +- valor
if(value > 32768):
value -= 65536
return value
def mpu6050_conv():
#bits de aceleração brutos
acc_x = read_raw_bits(ACCEL_XOUT_H)
acc_y = read_raw_bits(ACCEL_YOUT_H)
acc_z = read_raw_bits(ACCEL_ZOUT_H)
# bits temporários brutos
## t_val = read_raw_bits(TEMP_OUT_H) # uncomment to read temp
#pedaços brutos de giroscópio
gyro_x = read_raw_bits(GYRO_XOUT_H)
gyro_y = read_raw_bits(GYRO_YOUT_H)
gyro_z = read_raw_bits(GYRO_ZOUT_H)
#converter para aceleração em ge giroscópio dps
a_x = (acc_x/(2.0**15.0))*accel_sens
a_y = (acc_y/(2.0**15.0))*accel_sens
a_z = (acc_z/(2.0**15.0))*accel_sens
w_x = (gyro_x/(2.0**15.0))*gyro_sens
w_y = (gyro_y/(2.0**15.0))*gyro_sens
w_z = (gyro_z/(2.0**15.0))*gyro_sens
## temp = ((t_val)/333.87)+21.0 # descomente e adicione abaixo em troca
return a_x,a_y,a_z,w_x,w_y,w_z
def AK8963_start():
bus.write_byte_data(AK8963_ADDR,AK8963_CNTL,0x00)
time.sleep(0.1)
AK8963_bit_res = 0b0001 # 0b0001 = 16-bit
AK8963_samp_rate = 0b0110 # 0b0010 = 8 Hz, 0b0110 = 100 Hz
AK8963_mode = (AK8963_bit_res <<4)+AK8963_samp_rate # bit conversion
bus.write_byte_data(AK8963_ADDR,AK8963_CNTL,AK8963_mode)
time.sleep(0.1)
def AK8963_reader(register):
# ler os valores do magnetômetro
low = bus.read_byte_data(AK8963_ADDR, register-1)
high = bus.read_byte_data(AK8963_ADDR, register)
# combinado alto e baixo para valor de bit sem sinal
value = ((high << 8) | low)
# converter para +- valor
if(value > 32768):
value -= 65536
return value
def AK8963_conv():
# bits de magnetômetro brutos
loop_count = 0
while 1:
mag_x = AK8963_reader(HXH)
mag_y = AK8963_reader(HYH)
mag_z = AK8963_reader(HZH)
# a próxima linha é necessária para AK8963
if bin(bus.read_byte_data(AK8963_ADDR,AK8963_ST2))=='0b10000':
break
loop_count+=1
#converter para aceleração em ge giroscópio dps
m_x = (mag_x/(2.0**15.0))*mag_sens
m_y = (mag_y/(2.0**15.0))*mag_sens
m_z = (mag_z/(2.0**15.0))*mag_sens
return m_x,m_y,m_z
# Registros MPU6050
MPU6050_ADDR = 0x68
PWR_MGMT_1 = 0x6B
SMPLRT_DIV = 0x19
CONFIG = 0x1A
GYRO_CONFIG = 0x1B
ACCEL_CONFIG = 0x1C
INT_ENABLE = 0x38
ACCEL_XOUT_H = 0x3B
ACCEL_YOUT_H = 0x3D
ACCEL_ZOUT_H = 0x3F
TEMP_OUT_H = 0x41
GYRO_XOUT_H = 0x43
GYRO_YOUT_H = 0x45
GYRO_ZOUT_H = 0x47
#Registros AK8963
AK8963_ADDR = 0x0C
AK8963_ST1 = 0x02
HXH = 0x04
HYH = 0x06
HZH = 0x08
AK8963_ST2 = 0x09
AK8963_CNTL = 0x0A
mag_sens = 4900.0 # sensibilidade do magnetômetro: 4800 uT
# iniciar o driver I2C
bus = smbus.SMBus(1) # iniciar comunicação com ônibus i2c
gyro_sens,accel_sens = MPU6050_start() # instantiate gyro/accel
AK8963_start() # magnetômetro instanciar# MPU6050 9-DoF Example Printout
from mpu9250_i2c import *
time.sleep(1) # delay necessary to allow mpu9250 to settle
print('recording data')
while 1:
try:
ax,ay,az,wx,wy,wz = mpu6050_conv() # read and convert mpu6050 data
mx,my,mz = AK8963_conv() # read and convert AK8963 magnetometer data
except:
continue
print('{}'.format('-'*30))
print('accel [g]: x = {0:2.2f}, y = {1:2.2f}, z {2:2.2f}= '.format(ax,ay,az))
print('gyro [dps]: x = {0:2.2f}, y = {1:2.2f}, z = {2:2.2f}'.format(wx,wy,wz))
print('mag [uT]: x = {0:2.2f}, y = {1:2.2f}, z = {2:2.2f}'.format(mx,my,mz))
print('{}'.format('-'*30))
time.sleep(1)Armazenamento dos dados
Agora que temos o programa que coleta as informações do acelerometro, podemos preparar o padrão de armazenamento, criando estruturas em mysql que armazenam os dados, e que posteriormente, sejam analisadas.