Aprenda a medir inclinação com a Genuino 101

Neste artigo mostraremos como fazer para ler a aceleração e a inclinação utilizando uma placa Genuino 101 a partir de seu acelerômetro, embarcado no módulo Intel Curie. Faremos isso utilizando a interface Serial do computador e o terminal da IDE Arduino.

Sobre a placa Genuino 101

A empresa Arduino lançou a placa maker Genuino 101 com o módulo Intel Curie, responsável por ser a central de processamento dessa placa. Nesse módulo  já há embarcado:

• Processador de 32 bits Quark dual core (x86 e ARC), operando a 32 MHz cada um dos cores, com 24 KB de memória RAM e 196 KB de memória Flash;
• Módulo Bluetooth Low Energy (BLE);
• Acelerômetro de 6 eixos integrado;
• Giroscópio;
• RTC – Real Time Clock.

Para saber mais detalhes sobre a placa, veja os artigos a seguir:

• Intel e Arduino anunciam Arduino 101, escrito por Fábio Souza
• Genuino Intel 101, escrito pelo pessoal da Mouser
• Genuino 101 – Review da placa, escrito por mim

Teoria

Henrique Torres apresentou nesse texto, e também explicou nesse texto, o princípio de funcionamento de acelerômetros e giroscópios MEMS – Micro Electro Mechanical Systems. Vale a pena dar uma conferida em seu texto para entender como esses dispositivos funcionam por dentro, como são construídos e para que servem.

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

O acelerômetro digital é um desses componentes eletromecânicos que permite que seja lido, de forma digital, o valor da aceleração exercido nesse componente. Em muitos componentes de mercado, a leitura pode ser feita através de um barramento de comunicação serial, como a I2C ou SPI. Podemos utilizar o valor da aceleração em Gs, dependendo da sensibilidade que o componente tolera. Em diversos acelerômetros o parametro g é configurável digitalmente.

Para quem estiver interessado em como fazer para interfacear um circuito integrado de acelerômetro externo com um Arduino UNO, sugiro dar uma lida nesse post que Fabio Souza publicou no Embarcados, onde interfaceia uma pequena placa GY-521 com um CI de acelerômetro digital MPU-6050, confira neste link.

No caso dessa placa Genuino 101, a Intel disponibilizou uma API para que pudéssemos acessar o CI digital diretamente por software. O Acelerômetro já está integrado ao Módulo Intel Curie como mencionado anteriormente, e apenas precisamos setar o número de gs e fazer a leitura da aceleração. Os exemplos que estão disponibilizados na própria IDE Arduino já trazem tudo que precisamos pra entender como fazer de forma rápida para ler a aceleração e converter pra g. Tudo já está funcionando, basta carregar o exemplo, gravar e testar utlizando o terminal.

Com a informação de aceleração em mãos é possível obter a inclinação, se aplicarmos as leis de Newton, conforme aprendemos nos cursos de física. As equações que aplicamos para esse experimento estão mostradas a seguir:

Então para determinar a inclinação devemos aplicar a seguinte fórmula.

Para x:

Ângulo em relação a x = Arcotangente ( ( Aceleração_g de x ) /  raiz ( (Aceleração_g de y )^2 + (Aceleração_g de z )^ 2 )  )

Para y:

Ângulo em relação a y = Arcotangente ( ( Aceleração_g de y ) /  raiz ( (Aceleração_g de x )^2 + (Aceleração_g de z )^ 2 )  )

Para z:

Ângulo em relação a z = Arcotangente ( ( Aceleração_g de z ) /  raiz ( (Aceleração_g de y )^2 + (Aceleração_g de x )^ 2 )  )

Para ler a aceleração, como disse anteriormente, aproveitei o exemplo da própria biblioteca fornecida pela Intel. Para tal utilizei as funções CurieIMU.readAccelerometer e  convertRawAcceleration, que converte a aceleração em g.

Compilei, conectei o Arduino e gravei.

Abri o terminal da IDE Arduino e obtive a seguinte imagem. Todas as informações de inclinação referentes aos eixos X, Y e Z serão mostrados.

Mudei a orientação da placa, para detectar diferentes ângulos, e observei a variação dos valores da aceleração no terminal.

Utilizei o seguinte código-fonte utilizando a IDE Arduino.

/*
Parte desse software foi retirado do exemplo provido pela Intel no software Arduino
Para demonstrar como o BMI160 funciona. Modificações foram realizadas para que pudesse
Demonstrar a inclinação.
 
   This sketch example demonstrates how the BMI160 on the
   Intel(R) Curie(TM) module can be used to read accelerometer data
*/
 
#include "CurieIMU.h"
 
void setup() {
  Serial.begin(9600); // initialize Serial communication
  while (!Serial);	// wait for the serial port to open
 
  // initialize device
  Serial.println("Initializing IMU device...");
  CurieIMU.begin();
 
  // Set the accelerometer range to 2G
  CurieIMU.setAccelerometerRange(2);
}

void loop() {
  int axRaw, ayRaw, azRaw;     	// raw accelerometer values
  float ax, ay, az;
  float denomX_A, denomX_B, denomX_C, denomX_T;
  float denomY_A, denomY_B, denomY_C, denomY_T;
  float denomZ_A, denomZ_B, denomZ_C, denomZ_T;
  float angleX, angleY, angleZ;
 
  // read raw accelerometer measurements from device
  CurieIMU.readAccelerometer(axRaw, ayRaw, azRaw);
 
  // convert the raw accelerometer data to G's
  ax = convertRawAcceleration(axRaw);
  ay = convertRawAcceleration(ayRaw);
  az = convertRawAcceleration(azRaw);
 
  Serial.print("Aceleracao: X: ");
  Serial.print(ax);
  Serial.print(" \t Y: ");
  Serial.print(ay);
  Serial.print(" \t Z: ");
  Serial.print(az);
  Serial.print("\r\n"  );       
 
 
 
  //X-AXIS
  denomX_A = pow(ay, 2);
  denomX_B = pow(az, 2);
  denomX_C = denomX_A + denomX_B;
  denomX_T = pow(denomX_C, .5);                   //pow returns base raised to the power exponent
  angleX = atan(ax/denomX_T) * 180/PI;           //should calculate the angle on the X axis in
                                                                                //degrees based on raw data
                            	
  //Y-AXIS
  denomY_A = pow(ax, 2);
  denomY_B = pow(az, 2);
  denomY_C = denomY_A + denomY_B;
  denomY_T = pow(denomY_C, .5);                   //pow returns base raised to the power exponent
  angleY = atan(ay/denomY_T) * 180/PI;           //should calculate the angle on the Y axis in degrees based
                                                                                 // on raw data                       
 
  //Z-AXIS
  denomZ_A = pow(ax, 2);
  denomZ_B = pow(ay, 2);
  denomZ_C = denomZ_A + denomZ_B;
  denomZ_T = pow(denomZ_C, .5);               	
  angleZ = atan(az/denomY_T) * 180/PI;                             	
 
 
  Serial.print("Angulo em graus: X: ");
  Serial.print(angleX);
  Serial.print(" \t Y: ");
  Serial.print(angleY);
  Serial.print(" \t Z: ");
  Serial.print(angleZ);
  Serial.print("\r\n"  );       
}
 
float convertRawAcceleration(int aRaw) {
  // since we are using 2G range
  // -2g maps to a raw value of -32768
  // +2g maps to a raw value of 32767
 
  float a = (aRaw * 2.0) / 32768.0;
 
  return a;
}

Lembre que, se tiver algum problema pra gravar a placa e reproduzir esse tutorial, execute um reset da placa.

Gostou? Deixe seu comentário abaixo e, caso tenha reproduzido esse tutorial, conte pra gente como foi.

Agradeço a Francesco Sacco pela a ajuda a fazer esse post.