Sistemas embarcados estão em todo lugar: em carros, eletrodomésticos, relógios, nas famosas “maquininhas de cartão” e, acredito que muito em breve, nas roupas que vestimos. Apesar de estarem presentes em utilizações tão distintas, a quase totalidade dos sistemas embarcados possui um ponto em comum: interação com o ambiente. Seja para medir temperatura, detectar um toque, medir luminosidade, medir umidade relativa do ar, etc., um sistema embarcado sempre vai precisar mensurar algo do ambiente. Logo, a leitura correta e confiável de sensores é algo importantíssimo em se tratando de sistemas embarcados.
Um dos sensores mais utilizados em conjunto com sistemas embarcados são os acelerômetros, sensores capazes de medir acelerações em 1, 2 ou 3 eixos, com resoluções e limites dos mais variados. E é justamente do acelerômetro que este artigo irá tratar: o que é e como utilizá-lo (no caso, um acelerômetro de 3 eixos).
Este artigo utiliza como placa de desenvolvimento a Beaglebone Blue, placa da já consolidada linha Beaglebone, com foco em aplicações com robótica.
Material necessário
Para reproduzir os exemplos deste artigo, você precisará de:
Uma placa de desenvolvimento BeagleBone Blue
Um cabo micro-USB para programação e alimentação
Considerações iniciais
Este artigo considera que você já tem a Beaglebone Blue pronta para uso, ou seja:
- Esteja com sistema operacional (distribuição Linux Debian) instalado e operante
- Esteja com conectividade à Internet (via wi-fi) operante
- Tenha acesso via SSH à placa, de forma a poder executar comandos e programas via terminal.
Se você não estiver neste ponto, sugiro fortemente ler as informações da página oficial da Beaglebone Blue ( https://beagleboard.org/blue ) link antes de prosseguir.
Beaglebone Blue - visão geral
A BeagleBone Blue oferece um conjunto de recursos de hardware com foco em projetos de robótica, indo desde recursos de sensoriamento até controle completo de motores DC e servo-motores. Observe a figura 1, onde os recursos de hardware oferecidos são mostrados de forma geral.
A BeagleBone Blue utiliza o SiP (System in-Package) Octavo Systems OSD3358, o qual possui as seguintes especificações:
- Processador AM335x (ARM Cortex-A8, rodando a 1 GHz), muito similar ao utilizado na Beaglebone Black
- Memória eMMC de 4 GB
- 512 MB de memória RAM DDR3
- Assim como outras placas de desenvolvimento da linha BeagleBone, possui 2 PRU (Programmable Real-Time Units) de 32 bits rodando a 200 MHz. As PRUs são como microcontroladores independentes e tem como função principal permitir a execução de aplicações que necessitem de abordagem Real-Time (algo que não é possível em um sistema operacional como o Linux embarcado, por exemplo).
Além disso, se você precisar de mais memória de armazenamento é possível utilizar uma imagem para a placa gravada em um SD Card (veja slot do SD Card na figura 2) e, assim, ter a quantidade de memória de armazenamento desejada. Para baixar as imagens oficiais disponíveis, acesse este link (https://beagleboard.org/latest-images) e, para saber como colocá-la no SD Card e fazer a BeagleBone utilizá-la, acesse este outro link (https://elinux.org/Beagleboard:Updating_The_Software).
Periferia de hardware e recursos oferecidos:
Suporte à bateria: possui circuitos para utilizar e recarregar uma bateria LiPo de 2 células (7,4 V). A recarga é feita SOMENTE através de uma fonte de alimentação de 12 V (vendida separadamente)
Conectividade WI-FI e Bluetooth (BLE e Bluetooth 4.1)
Uma USB 2.0 Client para alimentação (da parte lógica) e comunicação
Uma USB 2.0 HOST
Circuitaria/drivers para controle de até 8 servo-motores
Circuitaria/drivers para controle de até 4 motores DC (consumindo até 1,2 A cada um). Há controle de sentido de rotação e velocidade de giro (com PWM)
Um chip IMU de 9 eixos, disponibilizando: acelerômetro, magnetômetro e giroscópio (através do chip MPU9250)
Barômetro e termômetro (através do chip BMP280)
I/Os disponíveis: 11 LEDs programáveis e 2 botões programáveis
Além disso, a BeagleBone Blue possui conectores destinados a:
- Conectores para até 4 encoders;
- Conector para módulo GPS
- Conectores para até 4 canais de ADC e GPIOs
- Conectores para UART e I²C
- Conector para SPI
- Conector para rádio DSM 2
Ainda sobre os conectores, uma peculiaridade da BeagleBone Blue é o uso de conectores do tipo JST. Embora não sejam tão comuns entre os hobistas e makers, estes conectores têm como característica serem bem firmes na conexão e por possuírem pequenas dimensões físicas. Como desvantagem, este tipo de conector costuma ser um pouco mais caro que os conectores mais comuns de mercado. Apesar de mais caros, o uso de conectores JST para projetos que estão sujeitos à vibração constante (algo inerente a projetos de robótica, por exemplo) é uma ótima escolha. Para saber a lista completa dos conectores JST presentes na Beaglebone Blue, acesse este link (https://github.com/beagleboard/beaglebone-blue/wiki/Accessories).
Biblioteca de software para interação com periferia de hardware
Uma biblioteca de software feita especialmente para permitir o uso de todos os recursos da placa é a Robotics Cape Library (https://github.com/StrawsonDesign/librobotcontrol).
Esta biblioteca é totalmente open-source e destinada para desenvolver projetos de robótica em C na BeagleBone Blue (também é possível utilização na BleagleBone Black, desde que nesse caso seja utilizado um shield/cape especial chamado Robotics Cape). Apesar de já ser parte integrante das imagens mais recentes da Beaglebone Blue, esta biblioteca pode ser obtida neste link (repositório oficial). Já a documentação da mesma pode ser obtida neste link (http://www.strawsondesign.com/docs/librobotcontrol/index.html).
Se você utilizar a versão mais recente da imagem para a Beaglebone Blue, esta biblioteca já estará instalada e pronta para uso, não necessitando portanto ser instalada.
Acelerômetro: o que é?
O acelerômetro é um dispositivo eletrônico capaz de mensurar acelerações em 1, 2 ou 3 eixos espaciais (x, y e/ou z). Um acelerômetro é comumente encontrado como parte de um chip do tipo IMU (do inglês Inertial Measurement Unit, ou Unidade de Medição Inercial, em tradução livre), onde pode constar outros elementos sensores inerciais distintos no mesmo chip (como é no caso da Beaglebone Blue, onde o chip IMU MPU9250 possui acelerômetro, magnetômetro e giroscópio.
Aprofundando-se mais em termos de microeletrônica, um acelerômetro é um dispositivo que faz parte do grupo de sistemas chamado MEMS (do inglês Micro Electro Mechanical Systems). Dispositivos deste grupo combinam sistemas mecânicos e elétricos de escala micrométrica para obter medições relacionadas à estado/estímulos inerciais e mecânicos. Ou seja, os dispositivos MEMS tornam possíveis as medições de grandezas mecânicas (como aceleração) combinando elementos mecânicos e elétricos muito pequenos, tudo encapsulado em um circuito integrado.
A(s) aceleração(ções) medida(s) por um acelerômetro são àquelas as quais o acelerômetro está submetido. Por exemplo, se o acelerômetro encontra-se fixado em um carro, a(s) aceleração(ções) medida(s) serão àquelas as quais o carro e o acelerômetro estão submetidas. Logo, obrigatoriamente, o acelerômetro precisa estar fixo ao corpo ao qual se deseja mensurar a(s) aceleração(ções), fator importante a ser considerado na sua aplicação em testes destrutivos / ensaios únicos.
Os acelerômetros mais comuns e utilizados do mercado comunicam-se com sistemas computadorizados (microcontroladores, microprocessadores, etc.) com base em barramentos de comunicação digital, sendo um dos mais comuns o I²C.
Em termos físicos e matemáticos, aceleração é a variação da velocidade no tempo e, por sua vez, a velocidade é a variação de deslocamento espacial no tempo. Portanto, acelerômetros são capazes de oferecer informações que, se matematicamente bem trabalhadas, são capazes de dizer muito sobre o movimento de um objeto no espaço. Por esta razão os acelerômetros são largamente utilizados em robótica.
Parametrizações comuns em acelerômetros
Os acelerômetros comerciais possuem seus parâmetros de medição configuráveis, ou seja, são oferecidas opções de parametrização (varia de acordo com o fabricante e modelo de acelerômetro) de forma a permitir que você ajuste o acelerômetro da melhor forma possível ao uso do mesmo.
Dentre os parâmetros oferecidos, os três mais comuns e importantes em acelerômetros comerciais são:
Sensibilidade (sensibility): a sensibilidade define em que range (ou intervalo) de aceleração o acelerômetro irá trabalhar / mensurar. Este intervalo é comumente dado em função de múltiplos de g, que significa aceleração da gravidade (aproximadamente 9,8m/s²), sendo que alguns acelerômetros ainda permitem ser configurados para fornecer as acelerações já diretamente em m/s².
No caso do acelerômetro presente na IMU da Beaglebone Blue, as opções de sensibilidade disponíveis são: +-2g, +-4g, +-8g e +-16g.
Taxa de amostragem (sampling rate): este parâmetro define quantas medições de aceleração (em todos os eixos atendidos pelo acelerômetro em questão) serão feitas por segundo (por isso, este parâmetro é normalmente especificado em Hz). Este parâmetro está altamente atrelado ao uso e frequência desejada de leitura da(s) aceleração(ções), portanto deve ser cuidadosamente pensado qual valor se escolher. Uma baixa taxa de amostragem pode implicar em erros muito grandes de estimativas de grandezas à partir da aceleração (como velocidade e deslocamento espacial, por exemplo).
Para o caso do acelerômetro presente na IMU da Beaglebone Blue, as opções de taxa de amostragem do acelerômetro são: 200Hz, 100Hz, 50Hz, 40Hz, 25Hz, 20Hz, 10Hz, 8Hz, 5Hz e 4Hz.
Filtro passa-baixa nativo (Native Filter Frequency - LDFP): boa parte dos acelerômetros comerciais já possuem normalmente um filtro passa-baixa embutido e parametrizável. Isso é muito bom, pois torna uma das etapas de condicionamento do sinal responsabilidade do acelerômetro, poupando tempo e processamento na CPU de seu projeto. Este filtro é parametrizável quanto à frequência do filtro passa-baixa, em Hz. A escolha de um valor de filtro-passa-baixa é algo altamente dependente da aplicação/uso destinado ao acelerômetro, sendo muitas vezes determinado de forma empírica.
No caso do acelerômetro presente na IMU da Beaglebone Blue, as opções de frequência para o filtro-passa baixa nativo são: 5Hz, 10Hz, 41Hz, 92Hz, 184Hz, 460Hz e filtro passa-baixa desligado (off).
Leitura do acelerômetro da Beaglebone Blue
Agora é hora de um pequeno programa-exemplo, o qual lê o acelerômetro da Beaglebone Blue e escreve na tela os valores lidos de acelerações nos três eixos (x, y e z). Neste exemplo é considerada a sensibilidade de +-2g, taxa de amostragem igual a 200Hz e frequência do filtro passa-baixa igual a 41Hz. Estes valores foram escolhidos sem razões especiais (já que este é apenas um programa-exemplo), portanto sinta-se à vontade para modificá-los de acordo com o uso que desejar.
A leitura do acelerômetro é feito num modo chamado DMP. Este modo faz com que, a cada aceleração lida, uma interrupção de software seja gerada, de forma que a aquisição e uso das acelerações possa ser feita em intervalos regulares.
/** * Programa-exemplo de uso do acelerômetro contido na IMU da * placa Beaglebone Blue * Autor: Pedro Bertoleti */ #include <stdlib.h> #include <stdio.h> #include <pthread.h> #include <rc_usefulincludes.h> #include <roboticscape.h> /* Variavel que informa se o programa deve continuar executando (= 1) ou não (= 0) */ static int running = 0; /* Struct contendo as leituras dos elementos da MPU */ /* (dos quais, no momento, só interessa o acelerômetro) */ static rc_imu_data_t data; /* Prototipos */ int init_acelerometro(void); void leitura_acelerometro_gerada(void); /* Tratamento de interrupção para capturar quando o usuário aperta Ctrl+C Para encerrar este programa-exemplo */ static void __signal_handler(__attribute__ ((unused)) int dummy) { running=0; return; } /* Funcao: habilita acelerometro * Parametros: nenhum * Retorno: -1: erro * 0: ok */ int init_acelerometro(void) { rc_imu_config_t conf; /* Inicialização do chip IMU */ if(rc_initialize()) return -1; conf = rc_default_imu_config(); conf.enable_magnetometer = 0; conf.accel_fsr = A_FSR_2G; /* Sensibilidade: +-2G */ conf.accel_dlpf = ACCEL_DLPF_41; /* Filtro passa-baixa em 41Hz */ conf.dmp_sample_rate = 200; /* Taxa de amostragem em 200Hz */ /* Inicializacao em modo DMP para aquisicao de aceleracoes em intervalos regulares */ if (rc_initialize_imu_dmp(&data, conf)) return -1; /* Configura a funcao de callback de aceleracao (nos tres eixos) */ rc_set_imu_interrupt_func(leitura_acelerometro_gerada); return 0; } /* Funcao: callback de aceleracao lida (modo DMP) * Parametros: nenhum * Retorno: nenhum */ void leitura_acelerometro_gerada(void) { float aceleracao_eixo_X = 0.0; float aceleracao_eixo_Y = 0.0; float aceleracao_eixo_Z = 0.0; int c = 0; /* Le as acelerações nos eixos x, y e z */ aceleracao_eixo_X = data.accel[0]; aceleracao_eixo_Y = data.accel[1]; aceleracao_eixo_Z = data.accel[2]; /* escreve na tela/terminal as aceleracoes lidas */ for (c=0; c<80; c++) printf("\n\r"); printf("\rx = %6.2f g; y = %6.2f g; z = %6.2f g\n", aceleracao_eixo_X, aceleracao_eixo_Y, aceleracao_eixo_Z); fflush(stdout); } int main(int argc, char *argv[]) { /* Configurando captura de sinais (para o usuário poder sair do programa com Ctrl+C */ signal(SIGINT, __signal_handler); running = 1; /* Configura acelerometro */ if (init_acelerometro() == -1) { perror("\nErro ao inicializar IMU. Finalizando programa...\n"); exit(-1); } /* O chip IMU está configurado e lendo aceleracoes. Agora, serão escritas na tela as acelerações lidas nos três eixos (x, y e z) Tais informaçoes serao lidas e escritas pela funcao callback de aceleracao (leitura_acelerometro_gerada()) */ while (running); /* Finalizacao do programa */ return 0; }
Salve o código-fonte como programa_exemplo_imu.c. Na mesma pasta que salvou o programa, salve o conteúdo abaixo num arquivo chamado Makefile:
TARGET = programa_exemplo_imu
include robotics.mk
Na mesma pasta que salvou o programa, salve o conteúdo abaixo num arquivo chamado robotics.mk:
CC := gcc LINKER := gcc -o CFLAGS := -c -Wall -O2 LFLAGS := -lm -lrt -lpthread -lroboticscape -lpaho-mqtt3c SOURCES := $(wildcard *.c) INCLUDES := $(wildcard *.h) OBJECTS := $(SOURCES:$%.c=$%.o) prefix := /usr RM := rm -f INSTALL := install -o root -g root -m 4755 INSTALLDIR := install -d -m 755 LINK := ln -s -f LINKDIR := /etc/roboticscape LINKNAME := link_to_startup_program $(TARGET): $(OBJECTS) @$(LINKER) $(@) $(OBJECTS) $(LFLAGS) $(OBJECTS): %.o : %.c $(INCLUDES) @$(CC) $(CFLAGS) -c $< -o $(@) all: $(TARGET) install: @$(MAKE) --no-print-directory @$(INSTALLDIR) $(DESTDIR)$(prefix)/bin @$(INSTALL) $(TARGET) $(DESTDIR)$(prefix)/bin clean: @$(RM) $(OBJECTS) @$(RM) $(TARGET) uninstall: @$(RM) $(DESTDIR)$(prefix)/bin/$(TARGET) runonboot: @$(MAKE) install --no-print-directory @$(LINK) $(DESTDIR)$(prefix)/bin/$(TARGET) $(LINKDIR)/$(LINKNAME) @echo "$(TARGET) Set to Run on Boot"
Finalmente, compile o programa com os seguintes comandos:
make clean make
Após a compilação, rode o programa com o seguinte comando:
sudo ./programa_exemplo_imu
Você verá na tela de seu terminal as acelerações lidas nos três eixos (x, y e z) conforme mostra a figura 3
Para sair do programa, pressione Ctrl+C e depois Ctrl+Z.
Utilização prática das medições de aceleração: estimar velocidade
Conforme foi dito no tópico anterior, a partir da aceleração de um dado objeto ao longo do tempo, matematicamente é possível obter a variação de velocidade e variação de deslocamento espacial deste mesmo objeto ao longo do tempo. Destas, a velocidade é a mais comumente obtida / mais utilizada.
Observe o gráfico da figura 3, um gráfico de aceleração ao longo do tempo. Nele, pode-se observar que a aceleração em t0 - representada por acc(t0) - é diferente da aceleração em t1 - representada por acc(t1). Da física, é possível dizer que a área abaixo de uma curva de aceleração ao longo do tempo (por exemplo, entre t0 e t1) é igual à variação de velocidade sofrida, também entre t0 e t1. Ainda, observe que tal área é aproximadamente à área de um trapézio, em azul na figura 4.
Logo, a variação de velocidade entre t0 e t1 pode ser matematicamente expressa pela fórmula da figura 5.
Logo, se for conhecida a velocidade instantânea em t0, a velocidade instantânea em t1 é expressa pela fórmula da figura 6.
Portanto, conhecendo-se a velocidade inicial de um corpo, é possívelobter as velocidades instantâneas em qualquer instante de tempo subsequente, desde que haja medições de aceleração suficientes para tal.
Conforme dito anteriormente, um acelerômetro é um dispositivo capaz de mensurar as acelerações em 1, 2 ou 3 eixos espaciais (x, y e/ou z). Logo, desde que as medições de acelerações nos eixos sejam feitas em intervalos regulares, é possível repetir o raciocínio da determinação da velocidade instantânea para determinar as velocidades instantâneas individuais em cada eixo. Observe a figura 7.
Ainda, em posse das velocidades instantâneas individuais em cada eixo, é possível obter o módulo (ou intensidade) da velocidade resultante do objeto, conforme mostra a figura 8.
Desta forma, a partir da medição (ou aquisição) das acelerações (nos eixos desejados) em intervalos de tempo regulares e da velocidade inicial de um objeto, é possível obter as velocidades em cada eixo. É importante ressaltar que quanto menor o intervalo de tempo e quanto mais regulares forem estes intervalos de aquisição das acelerações, menor o erro das velocidades.
Conclusão
Neste artigo vimos o que são acelerômetros, quais as parametrizações mais comuns dos mesmos e a como utilizar o acelerômetro da placa de desenvolvimento Beaglebone Blue. Ainda, vimos como, matematicamente, obter a velocidade (por eixo) a partir de medições sucessivas de aceleração (também por eixo).
Com os conceitos aqui apresentados, é possível utilizar o acelerômetro em inúmeros projetos da vida real e, além disso, ter ideias de novos projetos que dependem de informações de deslocamento/dinâmica espacial.
