Sismógrafo Híbrido GeoDynamics

Participantes:

Celso Bairros Varella Neto

Resumo do projeto:

Sismógrafo Híbrido para o monitoramento dos Parâmetros Dinâmicos de Barragens e Taludes

Descrição do projeto:

Atualmente ouvimos falar muito no rompimento de barragens, deslizamento de encostas e/ou taludes, sendo estes, desastres recorrentes na história da humanidade. Recentemente tivemos o rompimento das barragens de Fundão e Santarém em Mariana – MG, o qual ocasionou o desaparecimento de pessoas, destruição de diversas construções, a interrupção no fornecimento de água a milhares de famílias, poluição do rio São Francisco, o qual se estendeu até o oceano, ocasionando também a interrupção das atividades pesqueiras, entre outros.

Sabe-se que são diversos os fatores que podem desencadear o rompimento de uma barragem e/ou deslizamento de encostas e taludes. Estes fatores por sua vez, podem gerar efeitos secundários, como microtremores de terra e/ou a mudança na inclinação e orientação em parte das suas estruturas.

Deste modo, o monitoramento da dinâmica de tais estruturas, possibilitará uma remediação preditiva e/ou até mesmo predizer um possível acidente com certa antecedência. Diante disto, o presente projeto visa o desenvolvimento de um sismógrafo híbrido, o qual será capaz de coletar dados referentes aos níveis de vibrações do meio, através de sensores de vibração (geofones) e também coletar informações quanto a inclinação e o ângulo de azimute, por meio da utilização de acelerômetros e giroscópios do tipo MEMS. Todos os dados coletados serão armazenados localmente e enviados em tempo-real para um servidor através de um link Ethernet, o que possibilitará que técnicos devidamente treinados possam analisar as informações e tomar medidas mitigatórias quando necessário. Devido ao seu design inovador, será possível empregar vários destes sismógrafos num mesmo estudo, a fim de se formar uma rede de monitoramento, deste modo, provendo informações ao longo de toda a estrutura estudada.

O equipamento aqui proposto tem seu hardware dividido um duas etapas (Diagrama de Blocos), a saber:

Analógica:

Filtro Passa-Alta, Passivo, Freq. Corte 2Hz, 6dB/Oitava;

Filtro Passa-Baixa (Filtro Anti-Alias), Ativo, Freq. Corte 500 Hz, 36 dB/Oitava;

Amplificador Não Inversor, Ganho 21X;

Geofones Verticais e Horizontais de 4.5 Hz;

Digital:

Placa OM13070 – LPCXpresso 4337;

Placa OM13082 – LPC General Purpose Shield (IMU BMI160);

Módulo WIFI ESP8266;

Histórico do desenvolvimento:

1 – Projeto Básico (seleção dos sensores, escolha do hardware analógico e digital e seleção do ambiente de desenvolvimento);

2 – Projeto do Circuito Analógico (Filtros ativos e passivos, circuito de amplificação dos sinais analógicos, entre outros);

3 – Teste de Bancada dos Circuitos Analógicos (Análise Temporal e Espectral);

4 – Confecção Layout Circuito Impresso;

5 – Teste e Configuração do Sensor Inercial BMI160 (Acelerômetro e Giroscópio);

6 – Teste e Configuração do Conversor Analógico Digital 24-bit Sigma-Delta (ADS1220);

7 – Montagem da Placa do Circuito Analógico;

8 – Configuração e Teste do WIFI ESP8266;

9 – Integração das Diferentes partes (Hardware e Software);

10 – Teste do Protótipo completo do Sismógrafo Geodynamics;

11 – Envio de Dados para Nuvem (ThingSpeak);

Após os testes apontarem resultados satisfatórios referentes a integração de todos os componentes de hardware (diagrama de conexão) e software .

O protótipo foi colocado a prova, utilizando para isso a manipulação dos sensores no intuito de se gerar perturbações nos níveis de vibrações, bem como na modificação dos ângulos de inclinação, sendo estes dados enviados a nuvem, conforme a figura abaixo e disponíveis no seguinte link.

A seguir é apresentado um vídeo demonstrando o funcionamento do protótipo do sismógrafo híbrido GeoDynamics.

Um dos maiores desafios no desenvolvimento deste protótipo, foi o de encontrar os parâmetros construtivos dos filtros, bem como, integrar e sincronizar todas as etapas de hardware e software.

Todo material de relevância utilizado na construção deste protótipo estão disponíveis nos links abaixo:

1 – Código fonte completo está disponível no repositório do mbed, através do link.

2 – Esquemáticos, Modelos de bloco simplificado e Erratas, através do link.

Hardware:

ETAPA ANALÓGICA

Sabe-se que os tremores de terra gerados a grandes distâncias (tele-sismos) possuem frequências de vibração bem menores que 10 Hz, porém micro tremores gerados localmente apresentam frequências maiores. Diante disto, os sensores de vibração (geofones) empregados neste projeto apresentam frequência central de 4.5 Hz, com banda plana de passagem de até aproximadamente 1KHz, sendo sensíveis o suficiente para captar as vibrações geradas.

Deste modo, a fim de limitar as frequências dos sinais que serão digitalizados, foi desenvolvido um conjunto de filtros, conforme a imagem a seguir.

O primeiro filtro desenvolvido (destacado em verde), é do tipo passivo, passa alta, com frequência de corte em aproximadamente 2 Hz, com uma taxa de atenuação de 6dB/oitava. Este filtro foi desenvolvido no intuito de atenuar as frequências um pouco abaixo da frequência central dos sensores (4.5 Hz).

O segundo filtro implementado (destacado em vermelho), é do tipo passa-baixa ou anti-aliasing, o qual foi desenvolvido de modo a evitar o efeito de alias. O mesmo é de sexta ordem, o qual irá proporcionar uma atenuação de aproximadamente 36 dB/oitava. A aproximação escolhida para este filtro é a do tipo Butterworth, pois possui uma resposta plana na banda de passagem, deste modo, não amplificando e nem atenuando (ripples) as frequências presentes nesta banda, sendo 500 Hz a frequência de corte. Neste circuito foi empregada a técnica conhecida como terra virtual (destacado em azul), o qual é um nível dc (2.5 V) acima do terra do sistema, o qual irá possibilitar que o sistema funcione com uma simples fonte de alimentação de 5 V.

Como dito anteriormente, o geofone (sensor de vibração) empregado é sensível o suficiente para captar pequenas vibrações geradas localmente, pois possuí uma sensibilidade de 28.8 V/m/s (Volts por Metro por Segundo). Deste modo, a fim de adequar até os menores níveis de sinais captados pelos geofones, foi implementado um amplificador, do tipo não-inversor e com ganho aproximado 21 vezes.

ERRATA: Inicialmente no circuito de amplificação o R9 estava conectado ao GND, porém isto está incorreto, sendo que o correto é ligar este ao terra virtual (+2.5V ou VCC/2) como segue na figura:

Após finalizada a etapa de desenvolvimento dos circuitos analógicos (filtros e amplificador), o circuito de filtragem foi montado em Protoboard, para possibilitar a realização de testes de bancada, no intuito de verificar o real funcionamento e comprovar se os mesmos estão respondendo conforme os parâmetros do projeto.

O teste foi realizado através da aplicação de dois sinais distintos, porém de mesma amplitude na entrada do circuito de filtragem. O primeiro sinal possui frequência fixa de 50 Hz, valor este, abaixo da frequência de corte (Fc 500 Hz) do filtro ativo. Já o segundo sinal assumiu 4 valores de frequência que variaram de valores abaixo da frequência de corte, igual a frequência de corte e valores bem acima (150, 500, 1014 e 2048 Hz). Vale ressaltar que neste ensaio não foi utilizado a etapa de amplificação.

Através da análise dos gráficos de resposta temporal e espectral comprova-se que as frequências acima da frequência de corte (Fc 500 Hz) são atenuadas e as abaixo são preservadas, demonstrando a viabilidade do circuito de filtragem desenvolvido. Diante disto, os circuitos de filtragem e amplificação foram adotados para todos os 3 canais principais e um canal extra, para finalizar foi compilado o layout da placa de circuito impresso e posteriormente sua versão física final.

ETAPA DIGITAL

Por ser um sismógrafo “Híbrido”, assim, neste contexto o mesmo emprega tanto sensores de vibração (geofones) analógico, quanto sensores inerciais digitais (acelerômetro e giroscópio). Um dos adendos apresentados neste sismógrafo é a sua capacidade de medir os ângulos de inclinação relativo, entre a estrutura (barragem, talude, encosta, entre outros) e o sensor inercial. Por meio de tais informações será possível acompanhar o comportamento dos parâmetros dito estáticos (ângulo de inclinação da estrutura construída), quando uma estrutura dita estável, está sobre ações de forças externas, as quais façam com que os ângulos das estruturas sejam alterados.

Os sensores inerciais atualmente são empregados em diversos circuitos (desde a orientação em telefones celulares a sistemas de navegação de aviões, entre outros), sendo que o empregado neste projeto possuí a capacidade de medir a aceleração e a velocidade angular nos três eixos. Deste modo, por meio da combinação de ambos é possível obter os ângulos de inclinação com mais precisão, pois se trabalharmos somente com o acelerômetro, o mesmo é susceptível as acelerações provocadas por movimentos e pela ação de forças externa, porém o mesmo não acumula erros com o tempo. Já o giroscópio não é susceptível a forças externas, porém com o tempo as medidas da velocidade angular vão derivando.

Inicialmente calcula-se os ângulos de inclinação através dos dados do acelerômetro. Uma vez que a única força que atua sobre o mesmo é a força da gravidade, deste modo, os valores obtidos nas três componentes correspondem a gravidade, assim os ângulos resultantes serão a inclinação do plano do sensor, uma vez que a gravidade sempre é vertical. O exemplo apresentado na figura seguinte é utilizado para calcular o ângulo no plano 2D.

Assim, para calcular os ângulos de inclinação no plano 3D usa-se as seguintes fórmulas:

O segundo passo é encontrar os ângulos a partir do giroscópio. Para isso necessitamos integrar a velocidade e conhecer o ângulo inicial, conforme as fórmulas a seguir:

Após a obtenção dos ângulos individualmente, a partir de cada um dos sensores inerciais (acelerômetro e giroscópio), se faz necessário combiná-los de forma a se obter os ângulos de inclinação sem os erros inerentes de cada um dos sensores. Esta combinação é realizada através da utilização de um Filtro Complementar, o qual aplica um filtro passa-baixa nos ângulos obtidos pelo acelerômetro e um passa-alta nos ângulos obtidos pelo giroscópio. Para isto, são dados diferentes pesos para cada um dos ângulos e estes pesos são encontrados pela seguinte relação (a=t/t+dt), onde “a” é o peso dado aos ângulos do giroscópio, “t” é o tempo de resposta do filtro (neste projeto está sendo utilizado t=0.5, ou seja, variações de ângulo cujo o tempo é maior que 0.5s) e “dt” que é o tempo total que o loop do firmware leva para ser executado. Já o peso dado aos ângulos do acelerômetro são encontrados simplesmente subtraindo de 1, o valor de “a”.

No presente projeto o conjunto de sensores inerciais utilizado é o BMI160 (Bosch), disponibilizado pela “NXP Semiconductor” através de sua “Shield OM13082”. Tal sensor possuí integrado um acelerômetro e um giroscópio, sendo ambos tri-axiais. O mesmo é conectado a placa “LPCXpresso4337” via barramento I2C, sendo que o mesmo barramento também é compartilhado com o sensor de temperatura LM75D (NXP) e com o expansor de IOs PCA9535BS (NXP) presentes na shield, conforme o seguinte esquema.

Software/Firmware:

Até o presente momento foi desenvolvido um firmware de configuração e obtenção de dados do sensor inercial presente na “Shield OM13082”, sendo os dados adquiridos, enviados ao PC via porta USB. Este firmware foi desenvolvido para realizar testes de configuração e formatação dos dados (ângulos de inclinação), o mesmo se encontra sem a etapa de correção de offset.

O código está disponível no repositório do mbed, através do link:

#include "mbed.h"

/*Timer*/
Timer t;

/* defines the axis for acc and gyr */
#define ACC_NOOF_AXIS       3
#define GYR_NOOF_AXIS       2

/* bmi160 slave address */
#define BMI160_ADDR         ((0x68)<<1)

/*Value to convert rad to deg*/
#define RAD_DEG           57.29577951

/*Communication LPCXpresso4337 to PC*/ 
Serial pc(USBTX, USBRX); // tx, rx

/*Communication I2C*/
I2C i2c(P2_3, P2_4);


/* Buffer to store acc and gyr samples */
int16_t acc_sample_buffer[ACC_NOOF_AXIS] = {0x5555, 0x5555, 0x5555};
int16_t gyr_sample_buffer[GYR_NOOF_AXIS] = {0x5555, 0x5555};

/*Store result after correction raw value*/
double acc_result_buffer[ACC_NOOF_AXIS] = {0x5555, 0x5555, 0x5555};
double gyr_result_buffer[GYR_NOOF_AXIS] = {0x5555, 0x5555};

/*Store data to fusion filter and after filtered*/
double accel_ang_x, accel_ang_y;
double tiltx, tilty;
double tiltx_prev, tilty_prev;

/*Store register BMI160 to read and write*/
char i2c_reg_buffer[2] = {0};
 
int main() {
    pc.printf("Teste BMI160nr");
    pc.printf("Configurando BMI160...nr");
    wait_ms(250);
    
    /*Config Freq. I2C Bus*/
    i2c.frequency(20000);
    
    /*Reset BMI160*/
    i2c_reg_buffer[0] = 0x7E;
    i2c_reg_buffer[1] = 0xB6;    
    i2c.write(BMI160_ADDR, i2c_reg_buffer, sizeof(i2c_reg_buffer), false);
    wait_ms(200);
    pc.printf("BMI160 Resetadonr");
    
    /*Enable Accelerometer*/
    i2c_reg_buffer[0] = 0x7E;
    i2c_reg_buffer[1] = 0x11; //PMU Normal   
    i2c.write(BMI160_ADDR, i2c_reg_buffer, sizeof(i2c_reg_buffer), false);
    pc.printf("Acc Habilitadonr");
    
    /*Enable  Gyroscope*/
    i2c_reg_buffer[0] = 0x7E;
    i2c_reg_buffer[1] = 0x15;  //PMU Normal 
    i2c.write(BMI160_ADDR, i2c_reg_buffer, sizeof(i2c_reg_buffer), false);
    pc.printf("Gyr Habilitadonr");
    
    /*Config Data Rate ACC 1600Hz*/
    i2c_reg_buffer[0] = 0x40;
    i2c_reg_buffer[1] = 0x2C;    
    i2c.write(BMI160_ADDR, i2c_reg_buffer, sizeof(i2c_reg_buffer), false);
    pc.printf("Data Rate ACC Selecionado a 1600Hznr");
    
    /*Config Data Rate GYR 1600Hz*/
    i2c_reg_buffer[0] = 0x42;
    i2c_reg_buffer[1] = 0x2C;    
    i2c.write(BMI160_ADDR, i2c_reg_buffer, sizeof(i2c_reg_buffer), false);
    pc.printf("Data Rate GYR Selecionado a 1600Hznr");
    
    /*Config Range GYR 250º/s*/
    i2c_reg_buffer[0] = 0x43;
    i2c_reg_buffer[1] = 0x03;    
    i2c.write(BMI160_ADDR, i2c_reg_buffer, sizeof(i2c_reg_buffer), false);
    pc.printf("Range GYR Selecionado a 250deg/snr");
    
    wait_ms(2000);
    pc.printf("BMI160 Configuradonr");
    
        
    while(1) {
        
        /*Read Register Data of Accelerometer*/
        i2c_reg_buffer[0] = 0x12;
        i2c.write(BMI160_ADDR, i2c_reg_buffer, 1, true);
        i2c.read(BMI160_ADDR, (char *)&acc_sample_buffer, sizeof(acc_sample_buffer), false);
        
        /*Read Register Data of Gyroscope*/
        i2c_reg_buffer[0] = 0x0C;
        i2c.write(BMI160_ADDR, i2c_reg_buffer, 1, true);
        i2c.read(BMI160_ADDR, (char *)&gyr_sample_buffer, sizeof(gyr_sample_buffer), false);
        
        /*Convert raw data of accelerometer to g */
        acc_result_buffer[0] = (acc_sample_buffer[0]/16384.0);
        acc_result_buffer[1] = (acc_sample_buffer[1]/16384.0);
        acc_result_buffer[2] = (acc_sample_buffer[2]/16384.0);
        
        /*Convert raw data of gyroscope to deg/s */
        gyr_result_buffer[0] = (gyr_sample_buffer[0]/131.2);
        gyr_result_buffer[1] = (gyr_sample_buffer[1]/131.2);
                
        /*Compute tilt angle of accelerometer data*/
        accel_ang_x=atan(acc_result_buffer[0]/sqrt(pow(acc_result_buffer[1],2) + pow(acc_result_buffer[2],2)))*RAD_DEG;
        accel_ang_y=atan(acc_result_buffer[1]/sqrt(pow(acc_result_buffer[0],2) + pow(acc_result_buffer[2],2)))*RAD_DEG;
        
        /*Stop Timer*/
        t.stop();
                
        /*Compute rotation angle of gyroscope data and apply complementary filter to fusion data*/
        tiltx = (0.965*(tiltx_prev+(gyr_result_buffer[0]*t.read())))+(0.035*(accel_ang_x));
        tilty = (0.965*(tilty_prev+(gyr_result_buffer[1]*t.read())))+(0.035*(accel_ang_y));
        
        /*Debug to find loop time*/
        //pc.printf("%f",t.read());
        
        /*Reset Timer*/
        t.reset();
        /*Start Timer*/
        t.start();
        
        tiltx_prev = tiltx;
        tilty_prev = tilty;                                 
        
        /*Print Pitch and Roll*/
        pc.printf("%.3f,%.3fnr",tiltx, tilty);


         
        wait_ms(1);
    }
}

Como os sensores utilizados para obtenção dos níveis de vibrações do meio são analógicos, estes devem ser amostrados e quantizados para que tais níveis possam ser processados (transmissão, armazenamento e processamento matemático) digitalmente, para isto nesse projeto está sendo utilizado um conversor analógico digital com resolução de 24-bit, e taxa máxima de amostragem de 2000 amostras por segundo. A seguir é apresentado o código fonte utilizado para configurar e testar o ADC.

O código está disponível no repositório do mbed, através do link:

/*CODE TEST ADC ADS1220*/
/*ADS1220 LIBRARY MODIFIED OF SANDEEP MALLADI*/
/*https://developer.mbed.org/users/sandeepmalladi/code/ADS1220*/

#include "mbed.h"
#include "ADS1220.h"



#define PGA 1                 // Programmable Gain = 1
#define VREFE 5.0                // External reference of 5.00V
#define VFSR VREFE/PGA
#define FSR (((long int)1<<23))
#define LSB_Size (VFSR/FSR)

Serial pc(USBTX, USBRX);
ADS1220 ads1220_com(PTD2, PTD3, PTD1);
DigitalIn DRDY(D0);

Timer t;

void showvolt(float volts);
float code2volt(float c);
signed long t1Data, t2Data;
float Vout, volt;
char AIN1 = 57, AIN2 = 56;
int chn;

int main(){
    pc.baud (230400);   //Set a baudrate to unusual value of the 230400bps
    pc.printf("ADS1220 Inicializingnr");
    ads1220_com.Config();
    //Configure ADS1220 to Single Shot, Turbo Mode & 2000sps
    pc.printf("ADS1220 Configured and Inicializednr");

    
    wait_ms(500);
    
    while(1) {     
        t.start(); //Start Timer to Count Time Lapse
        
        ads1220_com.set_MUX(AIN1); //Configure to Sample Channel 1
        ads1220_com.SendStartCommand(); //Start Aquisition
        while (DRDY != 0){} // Wait data on Buffer
        t1Data = ads1220_com.ReadData(); //Read Data Sampled on Channel 1
                        
        ads1220_com.set_MUX(AIN2); //Configure to Sample Channel 2
        ads1220_com.SendStartCommand(); //Start Aquisition
        while (DRDY != 0){} // Wait data on Buffer
        t2Data = ads1220_com.ReadData(); //Read Data Sampled on Channel 2
        
        pc.printf("AIN1 %f - AIN2 %f nr",code2volt(t1Data), code2volt(t2Data)); //Print Data Formated
        t.stop();//Stop Timer to Count Time Lapse

        pc.printf("TEMPO %f nr", t.read()); //Print Time Lapse
        t.reset(); //Reset Timer Counter

    }
}

//Function to Convert ADC Data Read
float code2volt(float c)
{
    float Vout = 0;
    Vout = (float)(c*LSB_Size*1000);    //In  mV
    return Vout;
}

Após a integração das diferentes partes, tando de firmware como de hardware e verificado o correto funcionamento do protótipo do sismógrafo Geodynamics, o código fonte completo desta solução está disponível no repositório do mbed, através do link.