142

Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

Sistema para monitoramento de vibrações utilizando Arduino

Marco Antonio da Silva1

Alessandro Basaglia Carvalho1
Jean Cosme Garrido1
Marcos Antonio Estremote2

Resumo:
Este artigo aborda o uso da plataforma Arduino no desenvolvimento de uma solução para monitoramento remoto
de vibrações. O Arduino obtém informações do sensor (acelerômetro e giroscópio) de forma remota e é acessado
via interface SERIAL (porta USB) através de um programa que centraliza o monitoramento e gravação dos
dados obtidos. A comunicação entre Cliente e Servidor ocorre através de uma rede sem fio utilizando o rádio
NRF24L01. Para a implementação da solução foram utilizados as ferramentas: Visual Basic.Net, banco de dados
MySQL e rádio comunicador, 2.4 GHz, modelo NRF24L01.

Palavras-chave: Arduino. Monitoramento. Vibrações. Microcontrolador. Software.

1 Introdução
Com o avanço da tecnologia, os aparelhos eletrônicos ficaram mais inteligentes, com
mais recursos, necessitando cada vez mais se comunicarem entre si. Com isso a comunicação
paralela perdeu espaço devido à dificuldade em se estender barramentos paralelos a grandes
distâncias.
Houve então a necessidade de se utilizar o barramento serial e com isso vários tipos
diferentes de protocolos foram desenvolvidos.
Segundo Deshmukh (2011), atualmente é comum o uso de microcontroladores no
controle de vários processos. Um microcontrolador é um sistema microprocessador
encapsulado em um único chip, com memórias, clock e periféricos mais limitados que um
computador. O uso desses circuitos integrados não somente reduz custo da automação como
também propicia mais flexibilidade. Dentre as plataformas de desenvolvimento que utilizam
microcontroladores, o Arduino tem ganhado um grande destaque.
Arduino é uma plataforma de prototipagem aberta baseada em hardware e software
flexíveis e de fácil utilização segundo Banzi, (2011). O ambiente Arduino foi desenvolvido
para ser fácil para iniciantes que não possuem experiência com desenvolvimento de software
ou eletrônica (MARGOLIS, 2011). Neste contexto, este artigo apresenta uma solução para
monitorar vibrações de estruturas usando a arquitetura Arduino. O protótipo desenvolvido

1
Alunos do curso de Engenharia Civil – Faculdades Integradas Rui Barbosa (FIRB) – Andradina-SP
2
Professor do curso de Engenharia Civil – Faculdades Integradas Rui Barbosa (FIRB). E-mail:
estremot@gmail.com

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014

 143
Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

será responsável por controlar as vibrações através de um programa desenvolvido pelo grupo.
O protótipo desenvolvido será responsável por obter os dados das vibrações, tratá-los e
armazená-los.

2 Objetivos
Nesta seção são apresentados os objetivos deste trabalho:
2.1 Objetivo Geral
O objetivo geral do trabalho é propor uma solução com uso de hardware de baixo custo,
para monitorar vibrações em estruturas, de forma remota, armazenando-os em uma base de
dados que possa ser acessada pela web.
2.2 Objetivos Específicos
Os objetivos específicos são apresentar as vantagens da arquitetura Arduino e expor o
funcionamento da solução proposta.

2.3 Justificativa

O trabalho se justifica por propor uma solução de baixo custo, flexível e prática para o
monitoramento. Segundo Mcroberts (2011) o uso da plataforma Arduino tem como maior
vantagem a facilidade de sua utilização. Outro aspecto favorável ao uso do Arduino é a
grande comunidade de pessoas que compartilham códigos e diagramas de seus projetos para
que mais desenvolvedores copiem, modifiquem ou utilizem parte de suas ideias disseminando
ainda mais o uso da plataforma.

3 Solução proposta

A proposta foi criar um sistema composto de Software e Hardware de baixo custo e

alta flexibilidade de uso para monitoramento e coleta de dados de vibração em estruturas e
equipamentos (figura 1). O projeto então foi dividido em duas partes: um módulo transmissor
composto de sensor, microcontrolador e rádio transmissor com a finalidade de adquirir as
informações e transmití-la para o segundo módulo (receptor) composto por radio receptor,
microcontrolador e dispositivo de comunicação serial (USB), que serão detalhados a seguir.

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014

 144
Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

Figura 1: Arquitetura do projeto.

Fonte: elaborado pelos autores

3.1 Módulo transmissor

3.1.1 Hardware
Como funcionamento básico podemos descrever que o sensor MPU6050 captará as
variações de aceleração dos 3 eixos (x, y e z) através do componente acelerômetro e também a
variação angular de cada eixo através do componente giroscópio.
Essas informações são então repassadas ao microcontrolador por comunicação I²C, que
as formatará em um pacote e então o enviará ao rádio transmissor através de uma
comunicação SPI, para que este pacote seja transmitido até o módulo receptor.

Tabela 1 - Mapeamento de pinos entre sensor MPU6050 e Arduino e Radio NRF24L01+.

MPU-6050 ARDUINO NRF24L01+

Pino Função Pino Pino Função

1 VCC +5VCC

2 GND GND

3 SCL 28

4 DAS 27

5 XDA Não Conectado

6 XLC Não Conectado

7 ADO Não Conectado

8 INT Não Conectado

GND 1 GND

+3,3VCC 2 +3,3VCC

9 3 CE

10 4 CSN

13 5 SCK

12 6 MISO

11 7 MOSI

Não Conectado 8 IRQ

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014

 145
Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

O Arduino (figura 2) possui pinos específicos responsáveis

pela comunicação SPI e I²C. A tabela 1 mostra como
mapeamos os pinos do sensor MPU6050 (figura 2) e do rádio
transmissor NRF24L01 (figura 3) com os pinos do Arduino.
Figura 2 - Arduino Para alimentar o circuito utilizamos uma bateria com

duas células de 3,6v em série somando-se 7,2V, que foi

retirada de uma bateria de rádio VHF portátil que
estava sem uso e em perfeitas condições.
Figura 2: NRF24L01

Como pode ser

observado na
documentação técnica

o sensor MPU6050 Figura 3 - MPU6050

possui uma resolução

de 16 Bits na leitura. Isto significa que são possíveis 65536
representações de valores. Levando em consideração que ele
mede aceleração e variação angular com valores para mais e
para menos então se utiliza 32768 representações para valores
positivos e 32768 para valores negativos.
Nosso sensor foi configurado para medir aceleração de 2 vezes a gravidade (poderia ser
para até 16, conforme documentação técnica) isso torna o sensor mais sensível a pequenas
variações.
A aceleração da gravidade que para nossa cidade (Andradina - SP), segundo o IBGE –
Instituto Brasileiro de Geografia e Estatística através do Relatório de Estação Geodésica na
medição de 2010, é de 9,7854862 m/s². Multiplicando por 2 e dividindo por 32768
representações temos que o sensor pode nos informar variações com escala de 0,00059 m/s²,
ao passo que em 16g essas variações passariam para 0,0048 m/s².
O relatório citado pode ser visualizado através do site no seguinte link:
http://www.ibge.gov.br/home/geociencias/geodesia/bdgpesq_googlemaps.php

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014

 146
Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

3.1.2 O software
Para comunicarmos com o sensor e obtermos os valores, nós tínhamos duas opções:
desenvolver nossa própria biblioteca baseada nas regras do protocolo I²C e das informações
dos documentos técnicos do sensor ou utilizarmos uma biblioteca já pronta, dentre as várias
disponíveis gratuitamente pela internet.
Como o objetivo do projeto não é diretamente o estudo dos protocolos envolvidos
optamos por utilizar a biblioteca desenvolvida por Jeff Rowberg e que pode ser baixada
gratuitamente do site: https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050.
Para acessar então as informações do sensor utilizando essa biblioteca, foi necessário
acrescentar as seguintes linhas no código do transmissor:
Na seção de declaração de variáveis:
/*-----( Bibliotecas Necessárias )-----*/
/*---(PARA O MPU6050)---*/
#include "Wire.h"
#include "I2Cdev.h"
#include "MPU6050.h"
/*----------------------------------------------*/
MPU6050 sensor; //Objeto que representa o sensor MPU6050.

No procedimento Setup:
Wire.begin(); // inicia I2C bus.
sensor.initialize(); // inicia sensor MPU6050
SensorCon = sensor.testConnection(); //Testa a conexão com o sensor MPU6050.

No procedimento Loop:
//Obtém os dados do sensor MPU6050.
sensor.getMotion6(&dados[0], &dados[1], &dados[2], &dados[3], &dados[4], &dados[5]); //
Armazena as leituras do sensor MPU6050

O procedimento “getMotion6” faz a leitura dos 3 eixos do acelerômetro e dos 3 eixos

do giroscópio. Essas informações são armazenadas em uma variável do tipo vetor de 6
posições para que seja possível enviá-las para o rádio transmissor.

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014

 147
Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

Para o uso do radio transmissor também utilizamos uma biblioteca pronta que foi
desenvolvida por (maniacbug) que pode ser baixada gratuitamente do site:
https://github.com/maniacbug/RF24.
Para que o rádio funcione como transmissor e envie as leituras feitas pelo sensor foram
acrescentadas as seguintes linhas no código do transmissor.

Na seção de declaração de variáveis:

/*-----( Bibliotecas Necessárias )-----*/
/*---------(PARA O NRF24L01+)----------*/
#include "SPI.h"
#include "RF24.h"
#include "nRF24L01.h"
/*-------------------------------------*/
*-----( Declaração de Constantes e definição de Pinos )-----*/
#define CE_PIN 9 // (Chip Enable) Pino de controle Tx/Rx.
#define CSN_PIN 10 // (Chip Select NOT) SPI sinal.
const uint64_t pipe = 0xE8E8F0F0E1LL; // Define o Endereço do transmissor (pipe).
RF24 radio(CE_PIN,CSN_PIN); //Objeto que representa o radio NRF24LF01+.

No procedimento Setup:
radio.begin(); // inicia comunicação via radio
radio.setDataRate(RF24_2MBPS); // Define a velocidade de comunicação do rádio.
radio.setPALevel(RF24_PA_MAX); // Define o nível de potência da transmissão.
radio.setChannel(70); // Define o canal de comunicação.
radio.enableDynamicPayloads(); // Habilita o controle de pacotes automático.
radio.openWritingPipe(pipe); // Define o radio como transmissor

No procedimento Loop:
// Envia os dados via rádio NRF24L01+.
radio.write(dados, sizeof(dados));

3.2 O módulo receptor

3.2.1 O Hardware
Podemos descrever que os dados envidados pelo módulo transmissor serão captados
pelo radio NRF24L01+ e lidos pelo Arduino. Essas informações então serão repassadas a um

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014

 148
Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

terminal de computador por comunicação serial (RS232) através de uma emulação de uma
porta COM pela porta USB.
A velocidade máxima de comunicação entre os dois rádios é de 2 mbps e pode atingir
em condições favoráveis 10m de distância.
A Tabela 2 mostra como ligar os pinos do radio receptor com o Arduino.

Tabela 2: Mapeamento de pinos entre rádio NRF24L01+ e Arduino.

ARDUINO NRF24L01+
Pino Pino Função
GND 1 GND
+3,3VCC 2 +3,3VCC
9 3 CE
10 4 CSN
13 5 SCK
12 6 MISO
11 7 MOSI
Não Conectado 8 IRQ
Fonte: elaborado pelos autores

3.2.2 O Software
Assim como no módulo transmissor usamos a mesma biblioteca para acessar os dados
que chegam pelo rádio receptor.
As linhas de códigos são praticamente as mesmas com exceção de algumas linhas que
devem ser substituídas, pois um rádio é configurado somente como transmissor e outro
somente como receptor.
No procedimento Setup substituir radio.openWritingPipe(pipe); por:
radio.openReadingPipe(1,pipe); // Define o rádio como receptor.
E acrescentar :
radio.startListening(); // Inicia a escuta para aguardar recebimento dos dados.

Para o recebimento dos dados no procedimento Loop deve-se usar um laço de repetição
até que uma variável de controle seja marcada como verdadeiro quando da recepção total do
pacote enviado for concluída.

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014

 149
Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

// executa enquanto não obter toda a sequência de dados

while (!concluido)
{
concluido = radio.read( dados, sizeof(dados) ); // obtém os dados
}
Após montagem dos dois módulos com a utilização de dois kits do Arduino e
protoboads e desenvolvidos os softwares do transmissor e receptor, optamos por desenvolver
nossas próprias placas de circuito para eliminarmos alguns problemas que surgiram devido a
mau contato entre os diversos fios de conexão entre os dispositivos e a protoboard.
Pesquisando descobrimos o número mínimo de componentes necessários ao perfeito
funcionamento de um microcontrolador da Atmel o Atmega328pu com o bootloader do
Arduino. Para isso usamos como referência o projeto da placa “BlackBoard” da Robocore
que pode ser baixado gratuitamente do site: http://www.embarcados.com.br/placa-arduino-
da-robocore-blackboard/
Para desenvolvemos o nosso projeto, com o esquema mostrado na figura 5, utilizamos
como ferramenta gratuita, um programa que auxilia a montagem de projetos em placas de
circuito impresso universais, chamado “BlackBoard circuit designer” que pode ser baixado
pelo site: http://blackboard.serverpool.org
A figura 6 mostra a placa de circuito vista de cima com os componentes eletrônicos. A
mesma placa foi utilizada para os dois módulos (transmissor e receptor) o que diferenciou foi
somente o software carregado em cada microcontrolador.
O Esquema de soldagem das trilhas pode ser observado na figura 7 que mostra a vista
de baixo da placa de circuito impresso.

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014

 150
Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

Figura 3 - Esquema da placa Transmissor e Receptor.

Figura 4 - Placa Circuito impresso vista por cima.

Figura 5 - Placa Circuito Impresso vista por baixo.

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014

 151
Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

Para o recebimento e tratamento das informações recebidas no terminal de computador

através da porta USB, fez-se necessário o desenvolvimento de um programa que ficaria
encarregado de tempos em tempos escutar a porta de comunicação, ler os dados formatá-los
para m/s² (acelerômetro) e º/s (giroscópio) mostrá-los em uma interface amigável e também
gravá-los em uma base de dados para que as informações possam ser acessadas de outro
lugar®, Visual Studio® Express 2013 for Windows® que pode ser baixado gratuitamente do
site:
http://www.visualstudio.com/en-us/products/visual-studio-express-vs.aspx
Utilizamos a linguagem basic através do Visual Basic.net por ser de fácil utilização.
Para mostrar os dados em forma de gráfico utilizamos um componente adicional da
Microsoft® chamado MICROSOFT CHART CONTROLS FOR MICROSOFT .NET FRAMEWORK
3.5 que pode ser baixado do site: http://www.microsoft.com/pt-
br/download/details.aspx?id=14422
Ainda para visualização de cada eixo utilizamos outro componente adicional no Visual
Studio® que gera um medidor analógico (gauge), que pode ser baixado gratuitamente pelo
site: http://www.codeproject.com/Articles/17559/A-fast-and-performing-gauge
Os dados então são gravados em uma base de dados MYSQL para que se possa prover
acesso remoto a eles e manter um backup para posterior estudo.
A tela do programa é mostrada na figura 8.
Figura 6 - Tela principal do programa de monitoramento de dados.

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014

 152
Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

Código das principais funções do programa:

Procedimento que ocorre toda vez que chega dados pela porta serial:
Private Sub com_DataReceived(sender As Object, e As SerialDataReceivedEventArgs) Handles
com.DataReceived
Try
If com.IsOpen Then
BUFFER = com.ReadLine().Trim 'lê os dados e armazena na variável
readbuffer = True
End If
Catch ex As Exception
End Try
End Sub

Função de mapeamento do valor do sensor acelerômetro para m/s²:

Public Function map(Valor As Long) As Double

Return (Valor - Config.Sensor.Minimo) * (Config.Aceleracao.Maximo - Config.Aceleracao.Minimo) /
(Config.Sensor.Maximo - Config.Sensor.Minimo) + Config.Aceleracao.Minimo
End Function

Função de mapeamento do valor do sensor giroscópio para º/s:

Public Function mapGraus(valor As Long) As Double

Return (valor - Config.Sensor.Minimo) * (Config.Graus.Maximo - Config.Graus.Minimo) /
(Config.Sensor.Maximo - Config.Sensor.Minimo) + Config.Graus.Minimo
End Function

Após ler os dados para a variável BUFFER seu conteúdo é separado em variáveis
individuais para cada eixo e sensor e após o mapeamento dos valores pelas funções de
mapeamento, estes dados são mostrados no gráfico e nos mostradores analógicos e quando
solicitado pelo usuário eles são gravados na base de dados.

Considerações finais

O sistema mostrou-se eficaz ao que foi proposto e as tecnologias utilizadas

possibilitam o desenvolvimento de uma solução de baixo custo, uma vez que foi utilizado o
microcontrolador Arduíno e tecnologia de software gratuito disponível para uso.
O protótipo também se mostrou muito flexível para análises vibratórias de diversos
tipos de estruturas e equipamentos.

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014

 153
Marco A. da Silva; Alessandro B. Carvalho; Jean C. Garrido; Marcos Antonio Estremote

Referências

AGUIAR, Ygor Quadros de; MACIEL, Braian Konzgen; SOARES, Luciane Baldassari -
Universidade Federal de Rio Grande – FURG, Barramento Serial I²C e SPI, Disponível em:
<http://www.ebah.com.br/content/ABAAAe7xoAL/barramento-serial-spi-i-c>,Acesso em 25
de junho de 2014.

ARDUINO .cc, nRF24L01. Disponível em: <http:///playground.arduino.cc/interfacing

WithHardware / Nrf24L01> Acesso em: 28 de abril de 2014.

BANZI, M. Primeiros passos com o Arduino. São Paulo: Novatec, 2011.

DESHMUKH, A. V. Microcontrollers – Theory And Applications, 2011.

EVANS, Martin; NOBLE, Joshua; HOCHENBAUM, Jordan: Arduino em Ação. São Paulo:
Novatec, 2013.

INVENSENSE, MPU-6000 and MPU-6050: Product Specification, Revision 3.1 Disponível

em: <http://invensense.com/mems/gyro/documents/PS-MPU-6000A-00v3.4.pdf> Acesso em:
12 de abril de 2014.

LABORATÓRIO DE GARAGEM, Breakout MPU-6050 - Acelerômetro & Giroscópio.

Disponível em: <http://www.labdegaragem.org/loja/triple-axis-accelerometer-gyro-breakout-
mpu-6050.html> Acesso em: 10 de abril de 2014.

MANIACBURG; Biblioteca RF24 v1. Disponível em: <http://maniacbug. github.io

/RF24/index.html>. Acesso em: 10 de abril de 2014.

MARGOLIS, M. Arduino Cookbook. Sebastopol, CA, USA: O'RilleyMedia, 2011, p1.

MCROBERTS, M. Arduino Básico. São Paulo: Novatec, 2011.

PROTOCOLO SPI; Disponível em: <https://cld.pt/dl/download/03fa4282-3f3f-4231-8907-

2e21bfed8207/N3E%20%20SmartBoost/4%C2%BA%20Ano/1%C2%BA%20semestre/Siste
mas%20Embebidos/Prof.%20Rui%20Rocha/Projectos/protocolo_spi_v2.pdf>, Acesso em: 23
de junho de 2014.

SACCO, Francesco. Comunicação SPI. Disponível em: <http://www.embarcados.

com.br/spi-parte-1/>. Acesso em: 25 de junho de 2014.

WIKIPEDIA - Serial Peripheral Interface Bus, Disponível em:

<http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus>. Acesso em: 23 de junho de
2014.

WIKIPEDIA. Arduino. Disponível em: <http://pt.wikipedia.org/wiki/Arduino>. Acesso em:

15 de maio de 2014.

WIKISPACES. Nrf24L01-2.4GHz-HowTo. Disponível em: <http://arduino-info

.wikispaces.com/Nrf24L01-2.4GHz-HowTo> Acesso em: 28 de abril de 2014.

Revista InterAtividade, Andradina, SP, v.2, n. 2, 2º sem. 2014