Medição de ângulo com acelerômetro LIS3DH e Franzininho C0

16/08/2024

ÍNDICE DE CONTEÚDO

Este post faz parte da série Franzininho C0 com STM32CubeIDE

Introdução

No artigo anterior sobre o acelerômetro LIS3DH, ensinamos como realizar as leituras brutas do acelerômetro e convertê-las em miligramas (mg). No entanto, você sabia que também é possível calcular a angulação do dispositivo utilizando essas leituras de aceleração? Sim, é possível! Neste artigo, vamos modificar nosso código main.c para incluir a obtenção de dados de ângulo nos eixos X, Y e Z, permitindo uma análise completa da orientação do dispositivo.

Cálculo de inclinação

Para determinar a orientação de um dispositivo, utilizamos os valores de aceleração medidos pelo acelerômetro em cada eixo (X, Y e Z). A partir desses valores, podemos calcular os ângulos de inclinação em relação a cada eixo. Esses ângulos nos ajudam a entender a inclinação do dispositivo em relação a uma posição de referência.

Posição de Referência

A posição de referência é quando o dispositivo está com os eixos X e Y paralelos ao plano horizontal (sem aceleração nestes eixos, ou seja, 0 g) e o eixo Z perpendicular ao plano horizontal (com aceleração de 1 g devido à gravidade).

θ (Theta): Ângulo entre o eixo X do acelerômetro e o horizonte.
ψ (Psi): Ângulo entre o eixo Y do acelerômetro e o horizonte.
φ (Phi): Ângulo entre o eixo Z do acelerômetro e o vetor de gravidade.

Na posição de referência, onde não há inclinação (0 g nos eixos X e Y, e 1 g no eixo Z), todos os ângulos calculados serão 0°. Isso é mostrado na figura abaixo.

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

A trigonometria básica pode ser usada para mostrar que os ângulos de inclinação podem ser calculados usando a Equação 11, Equação 12 e Equação 13.

Se desejar aprofundar no assunto, sugiro a leitura de Application Note AN-1057 da Analog Devices.

Mão na massa, modificando o código main.c

Adicione as seguintes bibliotecas:

#include "lis3dh.h"
#include "stdio.h"
#include "string.h"
#include "math.h"

Lembrando que estamos utilizando o código base feito em lis3dh.h e lis3dh.c na parte 1 (link parte 1).

Em int main:

int main(void)
{
 /* USER CODE BEGIN 1 */
 /* USER CODE END 1 */
 /* MCU Configuration--------------------------------------------------------*/
 /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
 HAL_Init();
 /* USER CODE BEGIN Init */
 /* USER CODE END Init */
 /* Configure the system clock */
 SystemClock_Config();
 /* USER CODE BEGIN SysInit */
 /* USER CODE END SysInit */
 /* Initialize all configured peripherals */
 MX_GPIO_Init();
 MX_SPI1_Init();
 MX_USART1_UART_Init();
 /* USER CODE BEGIN 2 */
 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);
 HAL_Delay(500);
 LIS3DH_Init();
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
   int16_t accel[3];
   char uart_buf[100];
   // Leitura aceleracao em dados brutos
   LIS3DH_ReadAccel(accel);
   int32_t  Ax = (float)accel[0] / 16384.0; // Assumindo 2g sensibilidade
   int32_t  Ay = (float)accel[1] / 16384.0;
   int32_t  Az = (float)accel[2] / 16384.0;
   // Calcula os ângulos de inclinação em graus
   int32_t theta_x = atan2(Ax, sqrt(Ay * Ay + Az * Az)) * 180.0 / M_PI;
   int32_t theta_y = atan2(Ay, sqrt(Ax * Ax + Az * Az)) * 180.0 / M_PI;
   int32_t theta_z = atan2(Az, sqrt(Ax * Ax + Ay * Ay)) * 180.0 / M_PI;
   // Mostra UART
    sprintf(uart_buf, "Angulo X: %ld graus, Angulo Y: %ld graus, Angulo Z: %ld graus\r\n", theta_x, theta_y, theta_z);
   HAL_UART_Transmit(&huart1, (uint8_t*)uart_buf, strlen(uart_buf),     HAL_MAX_DELAY);
   HAL_Delay(5000); // Delay 5 segundos
 }
 /* USER CODE END 3 */
}

Basicamente, inicializamos nosso acelerômetro e no while realizamos os cálculos necessários para encontrar o valor da inclinação.

Após gravar o código, observamos os seguinte funcionamento:

Conclusão

Para concluir, este artigo mostrou como utilizar o acelerômetro LIS3DH em conjunto com a Franzininho C0 para calcular ângulos de inclinação nos eixos X, Y e Z. Ao modificar o código main.c conforme descrito, pudemos realizar leituras de aceleração, calcular os ângulos de inclinação utilizando trigonometria básica e exibir os resultados através da comunicação UART. Esses ângulos são essenciais para determinar a orientação do dispositivo em relação a uma posição de referência. Foi utilizado como base para esse código as bibliotecas e configurações feitas no artigo abordando o LIS3DH.