Nível de espírito digital baseado em Arduino e MPU6050: 3 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Bem-vindo ao meu primeiro instrutível! Espero que você ache isso informativo. Fique à vontade para deixar um feedback positivo ou negativo.

Este projeto é para fazer um nível de bolha digital baseado em arduino & MPU6050. Embora o design e o código acabados sejam meus, o conceito original e grande parte do código a partir do qual trabalhei não são. Não gosto de plágio, por isso estou mais do que feliz em dar crédito àqueles cujas ideias eu desenvolvi. As duas pessoas principais para as quais quero agradecer são Paul McWhorter e DroneBot Workshop do YouTuber. Incluo links para eles em meu PDF de links úteis do youtube. Obrigado também a EEEnthusiast por seu vídeo informativo sobre o uso do MPU6050, incluindo a configuração e leitura do módulo sem uma biblioteca externa (seu link está no mesmo PDF).

O projeto que produzi funciona "como está" e tem uma precisão fabulosa, certamente até 45% em qualquer direção. Você pode usá-lo exatamente como eu o projetei ou pode adaptá-lo ao seu gosto. Os mais astutos notarão que meu projeto parece quase idêntico ao produzido pela oficina DroneBot, mas tenha certeza, existem diferenças significativas, especialmente quando se trata do código para cálculo de ângulos, além da facilidade de armazenar valores de calibração em Eeprom!

Alguns recursos para abrir seu apetite:

Ângulos de inclinação e rotação disponíveis dentro de 0,1 grau.

Detecção automática de orientação da unidade giroscópica (horizontal ou vertical)

Calibração completa com resultados armazenados automaticamente no eeprom

Indicação de LED de -2 a +2 graus (alterável no código)

Indicação audível adicional de nível (pode ser ligado / desligado instantaneamente)

Curcuito compacto que requer componentes mínimos

Vamos começar.

Suprimentos

Este projeto (como está) usa os seguintes itens:

1 x Arduino nano (o meu é um clone)

1 x módulo giroscópio / acelerômetro MPU6050

1 x LCD - 16 x 2 + conexão I2C

1 x pressione para fazer a troca

1 x campainha piezo

1 x LED verde

2 x LEDs amarelos

2 x LEDs vermelhos

5 x resistores de 220 ohms

Vários cabos jumper

Tábua de pão

Fonte de alimentação (a minha usava um banco de energia USB de 5v, quando não estava conectada ao meu PC, mas você poderia usar uma bateria conectada adequadamente)

Etapa 1: O circuito

Supondo que você tenha todos os componentes, você precisará construir sua placa de ensaio.

Mostro minha configuração como um guia, mas as conexões são as seguintes:

O pino D2 do Arduino se conecta a 1 lado da chave de pressão. O outro lado da chave de pressão se conecta ao aterramento

O pino D3 do Arduino se conecta a 1 lado do resistor de 220 ohms. O outro lado do resistor se conecta ao anel do LED vermelho. O cátodo do LED vermelho vai para o aterramento.

O pino D4 do Arduino se conecta a 1 lado do resistor de 220 ohms. O outro lado do resistor se conecta ao anel do LED amarelo. O cátodo do LED amarelo vai para o aterramento.

O pino D5 do Arduino se conecta a 1 lado do resistor de 220 ohms. O outro lado do resistor se conecta ao anel do LED verde. O cátodo do LED verde vai para o aterramento.

O pino D6 do Arduino se conecta a 1 lado do resistor de 220 ohms. O outro lado do resistor se conecta ao anel do LED amarelo. O cátodo do LED amarelo vai para o aterramento.

O pino D7 do Arduino se conecta a 1 lado do resistor de 220 ohms. O outro lado do resistor se conecta ao anel do LED vermelho. O cátodo do LED vermelho vai para o aterramento.

O pino D8 do Arduino se conecta a um lado da campainha Piezo. O outro lado da campainha conecta-se ao aterramento.

O pino A4 do Arduino se conecta aos pinos SDA no MPU6050 E no LCD.

O pino A5 do Arduino se conecta aos pinos SCL no MPU6050 E no LCD

A alimentação 5v e Gnd para MPU6050 e LCD vêm dos pinos do Arduino Nano 5v e GND, respectivamente.

Depois de concluído, deve ser semelhante à minha configuração mostrada. Coloquei blu tak embaixo do MPU6050 para impedi-lo de se mover e também no LCD para mantê-lo na borda da placa de ensaio.

Etapa 2: O Código

O código em anexo é o código que usei para este projeto. A única biblioteca com a qual você pode ter problemas é a

Biblioteca LiquidCrystal_I2C.h porque a importei quando comecei a trabalhar com LCDs. Infelizmente, existem algumas bibliotecas que usam a mesma instrução #include, mas são ligeiramente diferentes. Se você tiver problemas com o seu, encontre outro código de LCD que funcione para você e altere o código de acordo. É provável que seja apenas a configuração que difere. Todos os comandos 'imprimir' devem funcionar da mesma forma.

Todo o código foi comentado e supondo que tenha feito certo, também haverá um vídeo explicando tudo, mas aqui estão alguns pontos a serem observados:

LiquidCrystal_I2C lcd (0x27, 16, 2);

O código acima é a configuração do meu LCD. Se sua biblioteca for diferente, você pode precisar alterar não apenas sua biblioteca, mas também esta linha.

{lcd.setCursor (0, 1); lcd.print ("Horizontal!"); orientação = HORIZONTAL; // Lê os dados brutos de acc e giroscópio do MPU-6050 1000 vezes para (int cal_int = 0; cal_int <1000; cal_int ++) {read_mpu_6050_data (); // Adicione o deslocamento gyro x à variável gyro_x_cal gyro_x_cal + = gyro_x; // Adiciona o deslocamento gyro y à variável gyro_y_cal gyro_y_cal + = gyro_y; // Adicione o deslocamento gyro z à variável gyro_z_cal gyro_z_cal + = gyro_z; // Adicione o deslocamento acc x à variável acc_x_cal acc_x_cal + = acc_x; // Adicione o deslocamento de acc y à variável acc_y_cal acc_y_cal + = acc_y; } // Divida todos os resultados por 1000 para obter o deslocamento médio gyro_x_cal / = 1000,0; gyro_y_cal / = 1000,0; gyro_z_cal / = 1000.0; acc_x_cal / = 1000,0; acc_y_cal / = 1000,0; horizonalCalibration = 255; eeprom_address = 0; EEPROM.put (eeprom_address, horizonalCalibration); eeprom_address + = sizeof (int); EEPROM.put (eeprom_address, gyro_x_cal); eeprom_address + = sizeof (float); EEPROM.put (eeprom_address, gyro_y_cal); eeprom_address + = sizeof (float); EEPROM.put (eeprom_address, gyro_z_cal); eeprom_address + = sizeof (float); EEPROM.put (eeprom_address, acc_x_cal); eeprom_address + = sizeof (float); EEPROM.put (eeprom_address, acc_y_cal); eeprom_address + = sizeof (float); // Observe que não estamos armazenando um deslocamento para acc_z, devido à gravidade! atraso (500); }

O bloco de código acima é executado na rotina de calibração. Este código é para calibração horizontal. Existe um código quase idêntico para a calibração vertical (note, o código sabe se o seu MPU6050 está montado horizontalmente ou verticalmente!). MPU6050, é lido 1000 vezes. os valores apropriados são adicionados cumulativamente e depois divididos por 1000 para dar um valor médio de 'compensação'. Esses valores são então armazenados no Nano eeprom. Todos os valores de calibração horizontal são armazenados começando no endereço eeprom 0. Todos os valores verticais são armazenados começando no endereço eeprom 24. A calibração DEVE ser feita em uma superfície completamente nivelada, caso contrário, eles não significam nada.

/ * * As próximas linhas processam os dados brutos para alterá-los em ângulos que podem ser enviados para o LCD e LEDs. * O valor de 4096, pelo qual os dados de aceleração são divididos, foi retirado da folha de dados MPU6050 e é baseado na taxa de amostragem. * O valor de 9,8 é a gravidade * A função atan2 é do módulo matemático e é usada para calcular os ângulos dos dados fornecidos * / thetaM = -atan2 ((acc_x / 4096,0) /9,8, (acc_z / 4096,0) /9,8) /2/3.141592656 * 360; // Dados brutos phiM = -atan2 ((acc_y / 4096.0) /9.8, (acc_z / 4096.0) /9.8) /2/3.141592656 * 360; // Dados brutos dt = (millis () - millisOld) / 1000.; millisOld = millis (); / * * Esta seção usa os dados do giroscópio para tornar o sistema mais responsivo * o valor de 65,5, pelo qual os dados do giroscópio são divididos, é retirado da folha de dados MPU6050 e é baseado na taxa de amostragem * / theta = (theta + (gyro_y / 65,5) * dt) *.96 + tetaM *.04; // Filtro passa-baixo phi = (phi + (gyro_x / 65.5) * dt) *. 96 + phiM *.04; // Filtro passa-baixo

O código acima é o que calcula os ângulos. Esperançosamente, os comentários fornecem uma pequena visão de como funciona, mas para uma explicação mais detalhada, confira o vídeo de Paul McWhorters no PDF anexado. O que direi, porém, é que você pode alterar a taxa de amostragem do giroscópio e do acelerômetro (o que é feito na sub-rotina de configuração MPU6050 na parte inferior do meu código). Se você alterar a taxa de amostragem, também terá que alterar por quanto os dados brutos são divididos. Para os dados do acelerômetro, o valor atual é 4096. Para o giroscópio, o valor atual é 65,5.

Consulte as folhas de dados em anexo e o vídeo de EEEntusiast (link no PDF em anexo) para obter informações mais detalhadas sobre como os valores de amostragem e deslocamento são encontrados.

Etapa 3: Próximas etapas

A esta altura, espero ter feito este projeto, mas e agora?

Em primeiro lugar, por que não construí-lo em um nível de bolha que você possa usar. Você pode comprar um nível de bolha barato (certifique-se de que é o tipo de caixa) que você pode adaptar, ou se você tiver o kit, imprimir seu próprio nível / caixa.

Talvez você possa brincar com as taxas de amostragem do giroscópio e do acelerômetro para ver se funcionam melhor em uma taxa do que em outra.

Tente refinar ainda mais o código. Por exemplo, atualmente, além de 45 graus, o ângulo declarado é, no mínimo, aproximado. Existe uma maneira de contornar isso?

Se você tiver alguma dúvida, não importa o quão simples pareça, pergunte. Se eu puder ajudar, ajudarei.

Se gostou deste instrutível, por favor, dê um like, para que eu saiba.

Se você fizer isso, por favor, mostre-me (especialmente se for em uma caixa de trabalho).

OBRIGADA