Gimbal de controle de movimento: 12 etapas

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

Olá a todos, Meu nome é Harji Nagi. Atualmente sou um estudante do segundo ano estudando eletrônica e engenharia de comunicação do Pranveer Singh Institute Of Technology, Kanpur (UP). Tenho um grande interesse em robótica, arduino, inteligência artificial e eletrônica analógica.

A palavra “gimbal” é definida como um suporte pivotado que permite a rotação de qualquer objeto em um único eixo. Portanto, um gimbal de três eixos permite que qualquer objeto montado no gimbal seja independente do movimento de quem está segurando o gimbal. O cardan dita o movimento do objeto, não daquele que o carrega.

Ele consiste em 3 servo motores MG996R para o controle de 3 eixos e uma base na qual o sensor MPU6050, o Arduino e a bateria serão colocados. É usado para manter a câmera estabilizada sem vibração. Um gimbal de 3 eixos garante que o movimento da câmera seja estabilizado mesmo se quem a está segurando está indo para cima e para baixo, para a esquerda e para a direita, para a frente e para trás. Isso é o que chamamos de estabilização de guinada, inclinação e rotação.

Etapa 1: lista de componentes

A lista de componentes são:

1) Arduino Uno

2) Bateria de 8 V, 1,5 Amp para alimentar o Arduino Uno

3) 7805 Regulador de tensão Ic ou você pode usar convetador de Buck

4) MPU 6050

5) 3 * (motores MG995 SERVO)

6) Fios de ligação

Outros equipamentos:

1) Ferro de solda

2) Pistola de cola

3) Máquina de perfuração

4) Comida pode

Em vez de usar breadborad, usei uma pequena placa de perf de coustom para conexão de barramento positiva e negativa

Etapa 2: montagem

Foamcore, placa de espuma ou placa de espuma com face de papel é um material leve e de fácil corte, usado para montar o servo motor e fazer modelos em escala.

Em primeiro lugar fiz uns suportes em forma de L DIY para montar servo motor com a ajuda de placa de espuma.

Etapa 3:

Montar o gimbal foi muito fácil. Comecei instalando o servo Yaw, o sensor MPU 6050 e o interruptor ON-OFF. Usando parafusos e porcas, fixei-o na base

Etapa 4: Em seguida, usando o mesmo método que prendi o Servo Roll. as peças são especificamente projetadas para caber facilmente nos servos MG995

Etapa 5: Em seguida, usando o mesmo método que prendi o Servo Roll. as peças são especificamente projetadas para caber facilmente nos servos MG995

Etapa 6: conexões

No diagrama de circuito você pode usar o conversor de buck ou o regulador de tensão 7805 IC para converter 8V em 5 V. O microcontrolador que recebe o diagrama de circuito é Arduino Nano, você também pode usar Arduino Uno, Arduino Mega.

Os pinos SCL e SDA do MPU 6050 são conectados ao pino A5 e A4 do Arduino Analog. (Os pinos SCL e SDA podem variar, portanto, verifique a folha de dados para os pinos SCl e SDA de outro microcontrolador)

Etapa 7: Conexão com IC regulador de tensão 7805

Este diagrama de circuito é para a conexão do regulador de tensão 7805 ic, conecte a bateria de 8v no Vin e você obterá uma tensão de saída de 5v.

Etapa 8: codificação

Você deve incluir as seguintes bibliotecas:

1) #includeClique aqui para baixar o arquivo zip

2) #includeClique aqui para baixar o arquivo zip

Depois de baixar o arquivo zip, adicione a biblioteca zip no esboço do Arduino

Para Código

/*

DIY Gimbal - MPU6050 Arduino Tutorial Code baseado no exemplo MPU6050_DMP6 da biblioteca i2cdevlib de Jeff Rowberg: https://github.com/jrowberg/i2cdevlib * / // I2Cdev e MPU6050 devem ser instalados como bibliotecas, ou então o.cpp / arquivos.h // para ambas as classes devem estar no caminho de inclusão de seu projeto #include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" // # include "MPU6050.h" // não é necessário se usar o arquivo de inclusão MotionApps / / A biblioteca Arduino Wire é necessária se a implementação I2Cdev I2CDEV_ARDUINO_WIRE // for usada em I2Cdev.h #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #include "Wire.h" #endif #include // o endereço I2C padrão da classe é 0x68 // passado como um parâmetro aqui // AD0 baixo = 0x68 (padrão para quebra de SparkFun e placa de avaliação InvenSense) // AD0 alto = 0x69 MPU6050 mpu; // MPU6050 mpu (0x69); // <- usar para AD0 alto // Definir os 3 servo motores Servo servo0; Servo servo1; Servo servo2; flutuar correto; int j = 0; #define OUTPUT_READABLE_YAWPITCHROLL #define INTERRUPT_PIN 2 // use o pino 2 no Arduino Uno e na maioria das placas bool blinkState = false; // controle / status MPU vars bool dmpReady = false; // define verdadeiro se a inicialização DMP foi bem-sucedida uint8_t mpuIntStatus; // mantém o byte de status de interrupção real do MPU uint8_t devStatus; // retorna o status após cada operação do dispositivo (0 = sucesso,! 0 = erro) uint16_t packetSize; // tamanho do pacote DMP esperado (o padrão é 42 bytes) uint16_t fifoCount; // contagem de todos os bytes atualmente em FIFO uint8_t fifoBuffer [64]; // buffer de armazenamento FIFO // orientação / movimento vars Quaternion q; // [w, x, y, z] contêiner de quatérnio VectorInt16 aa; // [x, y, z] medições do sensor de aceleração VectorInt16 aaReal; // [x, y, z] medições do sensor de aceleração sem gravidade VectorInt16 aaWorld; // [x, y, z] medições do sensor de aceleração de quadro mundial VectorFloat gravity; // [x, y, z] vetor de gravidade float euler [3]; // [psi, theta, phi] Contêiner do ângulo de Euler float ypr [3]; // [yaw, pitch, roll] yaw / pitch / roll container e vetor de gravidade // estrutura do pacote para demonstração do bule de chá InvenSense uint8_t teapotPacket [14] = {'$', 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x00, '\ r', '\ n'}; // ====================================================== ================ // === ROTINA DE DETECÇÃO DE INTERRUPÇÃO === // ===================== =================================================== volatile bool mpuInterrupt = false; // indica se o pino de interrupção MPU ficou alto void dmpDataReady () {mpuInterrupt = true; } // ======================================================= =================== // === CONFIGURAÇÃO INICIAL === // ======================= =================================================== void setup () {// junte-se ao barramento I2C (a biblioteca I2Cdev não faz isso automaticamente) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin (); Wire.setClock (400000); // Clock I2C de 400 kHz. Comente esta linha se estiver tendo dificuldades de compilação #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire:: setup (400, true); #endif // inicializar a comunicação serial // (115200 escolhido porque é necessário para a saída do Teapot Demo, mas // realmente depende de você dependendo do seu projeto) Serial.begin (38400); while (! Serial); // aguarde a enumeração de Leonardo, outros continuam imediatamente // inicializar o dispositivo //Serial.println(F("Initializing I2C devices… ")); mpu.initialize (); pinMode (INTERRUPT_PIN, INPUT); devStatus = mpu.dmpInitialize (); // forneça seus próprios offsets de giroscópio aqui, escalonados para sensibilidade mínima mpu.setXGyroOffset (17); mpu.setYGyroOffset (-69); mpu.setZGyroOffset (27); mpu.setZAccelOffset (1551); // 1688 padrão de fábrica para meu chip de teste // certifique-se de que funcionou (retorna 0 em caso afirmativo) if (devStatus == 0) {// liga o DMP, agora que está pronto // Serial.println (F ("Ativando DMP… ")); mpu.setDMPEnabled (true); attachInterrupt (digitalPinToInterrupt (INTERRUPT_PIN), dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus (); // define nosso sinalizador DMP Ready para que a função loop () principal saiba que está tudo bem em usá-lo //Serial.println(F("DMP ready! Waiting for first interrupt… ")); dmpReady = true; // obtém o tamanho do pacote DMP esperado para comparação posterior packetSize = mpu.dmpGetFIFOPacketSize (); } else {// ERROR! // 1 = falha no carregamento da memória inicial // 2 = falha nas atualizações de configuração do DMP // (se houver falha, geralmente o código será 1) // Serial.print (F ("Falha na inicialização do DMP (código")); //Serial.print(devStatus); //Serial.println (F (")")); } // Defina os pinos aos quais os 3 servo motores estão conectados servo0.attach (10); servo1.attach (9); servo2.attach (8); } // ======================================================= =================== // === PROGRAMA PRINCIPAL LOOP === // ==================== ================================================== void loop () {/ / se a programação falhou, não tente fazer nada se (! dmpReady) retornar; // aguarde a interrupção do MPU ou pacote (s) extra (s) disponíveis enquanto (! mpuInterrupt && fifoCount <packetSize) {if (mpuInterrupt && fifoCount

= 1024) {

// redefine para que possamos continuar de forma limpa mpu.resetFIFO (); fifoCount = mpu.getFIFOCount (); Serial.println (F ("estouro de FIFO!")); // caso contrário, verifique a interrupção dos dados DMP (isso deve acontecer com frequência)} else if (mpuIntStatus & _BV (MPU6050_INTERRUPT_DMP_INT_BIT)) {// aguarde o comprimento correto dos dados disponíveis, deve ser uma espera MUITO curta (fifoCount 1 pacote disponível / / (isso nos permite ler imediatamente mais sem esperar por uma interrupção) fifoCount - = packetSize; // Obter valores de Yaw, Pitch e Roll #ifdef OUTPUT_READABLE_YAWPITCHROLL mpu.dmpGetQuaternion (& q, fifoBuffer); mpu.dmpGetGravity (& q); gravity (& q); mpu.dmpGetYawPitchRoll (ypr, & q, & gravity); // Valores Yaw, Pitch, Roll - Radianos para graus ypr [0] = ypr [0] * 180 / M_PI; ypr [1] = ypr [1] * 180 / M_PI; ypr [2] = ypr [2] * 180 / M_PI; // Pula 300 leituras (processo de autocalibração) if (j <= 300) {correct = ypr [0]; // Yaw começa em um valor aleatório, então nós capturar o último valor após 300 leituras j ++;} // Após 300 leituras else {ypr [0] = ypr [0] - correto; // Defina o Yaw para 0 graus - subtraia o último valor aleatório de Yaw do valor atual para fazer o Yaw 0 graus es // Mapeie os valores do sensor MPU6050 de -90 a 90 para valores aceitáveis para o servo controle de 0 a 180 int servo0Value = map (ypr [0], -90, 90, 0, 180); Int servo1Value = map (ypr [1], -90, 90, 0, 180); Int servo2Value = map (ypr [2], -90, 90, 180, 0); // Controle os servos de acordo com a orientação MPU6050 servo0.write (servo0Value); servo1.write (servo1Value); servo2.write (servo2Value); } #fim se } }

Finalmente, usando a função de escrita, enviamos esses valores para os servos como sinais de controle. Claro, você pode desabilitar o servo Yaw se quiser apenas a estabilização para os eixos X e Y, e usar esta plataforma como gimbal da câmera

Etapa 9: quando todos os componentes estão conectados, sua aparência é semelhante a esta imagem

Etapa 10: Agora insira todos os ingredientes básicos dentro da lata de alimentos

Etapa 11: Quando todos os fios e componentes forem colocados dentro de um alimento, pode-se aplicar a pistola de cola na base da placa de espuma

Etapa 12: Conclusão

Observe que este gimbal de câmera está longe de ser bom. Os movimentos não são suaves porque esses servos não se destinam a esse propósito. Os gimbais de câmera real usam um tipo especial de motor BLDC para obter movimentos suaves. Portanto, considere este projeto apenas para fins educacionais.

Isso seria tudo por este tutorial, espero que tenham gostado e aprendido algo novo. Sinta-se à vontade para fazer qualquer pergunta na seção de comentários abaixo e não se esqueça de verificar minhas coleções de projetos