Teknologi micro controller dari Arduino dapat digunakan untuk otomatisasi.

Banyak proyek Arduino yang sederhana mengunakan mikrocontroller, mudah di program dengan peralatan murah.
Membuat rutinitas atau perangkat otomatisasi.

Dari sensor cuaca, IoT, otomatisasi mesin yang berulang, sensor suhu, kontrol termal dan lainnya.

Ada kebutuhan sistem kontrol suhu ruangan dengan udara diluar, dan diatur dengan mesin membuka tutup lubang angin
Dapat ditempatkan 2 sensor yang membandingkan kapan lubang udara ditutup, bila udara luar lebih panas. Dan sebaliknya, seluruhnya bekerja otomatis sesuai data sensor.

Kita dapat memprogram dengan harware untuk otomatis menyiram kebun. Diatur pada waktu tertentu pompa bekerja.
Atau sistem irigasi dengan sensor kelembaban tanah, bahkan kontrol PH sampai nutrisi secara otomatis
Dapat dipantau dengan internet, data logger untuk catatan selama 24 jam.

Untuk membayangkan, mungkin kita baru mengetahui dasar cara kerja microcontroller, sisanya copy paste program. Dan disesuaikan kembali untuk kebutuhan kita.
Mau ditambah dengan perangkat lain, itu nanti. Intinya belajar dasar, apa yang dapat dilakukan dari perangkat mikrocontroller.

Bagian penting dengan mengenal cara kerja perangkat Arduino.
Dari membuat program, upload ke micro controller, dan di aplikasikan untuk berbagai kebutuhan.


Salah satu perangkat sederhana seperti gimbal atau penyeimbang camera, kelihatan canggih.
Tentu saja disain gimbal di camera profesional membutuhkan hardware lebih komplek dan harganya mahal.
Prinsip kerjnya sama saja, dengan sensor keseimbangan.

Dalam 2 tahun terakhir, sering muncul alat gimbal camera untuk smartphone, harga lebih murah dibawah 1 jutaan.
Mengunakan 3 axis atau 3 sudut gerakan, dari berputar, keseimbangan vertikal, dan arah camera.

Tujuannya, ketika camera bergerak, posisi smartphone tetap lurus ke objek. Atau diarahkan ke sudut tertentu tanpa mengeser bidang gambar.

Beberapa pengemar membuat gimbal dengan 2 axis yang lebih sederhana.
Agar camera stabil mengarah ke satu bidang, dan fokus ke arah tersebut.
Walau camera masih tetap bergerak ke kiri dan ke kanan mengikuti arah tangan.

Belajar membuat gimbal dapat dimulai dengan 1 axis atau sudut.
Mengambil posisi camera tetap tegak lurus ke arah bidang walau tangan kita bergerak.

Perangkat yang dibutuhkan sangat sederhana
1. Microcontroller Arduino
2. ModulMPU 6050 sebagai sensor sudut atau axis

3. Motor yang disebut Servo motor dengan sudut 180 derajat

Sisanya adalah bracket camera dan servo untuk menempatkan peralatan camera dan mounting smartphone.
Terakhir baterai, dapat mengunakan baterai permanen, atau cukup dengan power bank 5V.

Komponen gimbal camera 1 Axis

Membuat sirkuit dengan Arduino Nano
Untuk gimbal 1 axis, cukup dengan 1 servo. Walau program yang diberikan nanti dapat mengunakan 2 axis atau 2 sudut untuk stabil ke arah atas bawah dan kiri kanan.

Koneksi microcontroller Arduino terhubung ke sensor keseimbangan MPU 6050. Modul ini paling murah, kedepan bila sudah membayangkan seperti apa perangkat yang dibuat, dapat menganti dengan alat keseimbangan lebih baik.

Terhubung ke servo motor. Di alat ini sudah diatur mengatur gerakan sampai batas 180 derajat. Dan di set untuk keseimbangan tangan agar tetap berada di posisi vertikal.

Gimbal Arduino single axis

Rancangannya seperti dibawah ini, sebelum perangkat dipasang ke mounting camera, dan pegangan atau tripod gimbal
Kira kira setelah bisa membuat alat dibawah ini, kedepan dapat di tambahan 2 bahkan 3 sudut gimbal yang lebih canggih.

Gambar gimbal buatan sendiri

Bagaimana cara kerja MPU 6050. Sensor tersebut mengikuti medan magnet atau posisi atas bawah dan kiri serta kanan.
Untuk 1 axis disini parameter yang diambil adalah keseimbangan vertikal atau agar camera tetap lurus pada bidang gambar.

Modul MPU 6050 sebagai sensor, akan mengirim sinyal bila modul tersebut terjadi gerakan
Misal modul di miringkan ke kiri dan ke kanan, dan sinyal di kirim lalu di olah ke microcontroller.
Dari microcontroller akan mengirim kembali sinyal sudut ke servo motor.
Jadi modul + microcontroller + servo bekerja bersamaan untuk menjaga camera tetap tegak lurus ke bidang.

Cara kerja Gimbal camera

Berapa harga komponen utamadengan 1 axis
Servo 60 ribu
Microcontroller 60 ribu
MPU 6050 20 ribu
Total 140 ribu.

Sedangkan yang lain seperti baterai powerbank dapat dibuat sendiri. Untuk 2 axis dapat ditambah 1 unit servo.
Dan mounting untuk servo single axis dapat mengunakan plastik atau plat aluminium
Sisanya untuk baut dan mounting smartphone.


Kekurangan ada di servo, yang 60 ribuan memiliki suara bising ketika bekerja.
Ini awal kita membuat sebuah gimbal sendiri, bila ada kebutuhan dapat dipertimbangkan menganti ke komponen lebih baik dengan servo yang tidak bising, dan modul Gyro yang lebih canggih.

Untuk gimbal yang sudah jadi, dan siap pakai. Dapat mengunakan model gimbal camera smartphone yang murah dengan 3 sudut, dengan model lebih praktis.
Sekarang hanya 800 ribuan dengan motor kecil, tapi model gimbal keseimbangan camera DSLR sepertinya masih lebih mahal.

Cara gimbal 1 axis dapat dilihat dibawah ini.



Apakah penyeimbang gimbal ini hanya untuk camera

Sebenarnya banyak tool yang dapat memanfaatkan keseimbangan untuk sudut tetap stabil.
Menempatkan camera ActionCam dibelakang kendaraan roda 2 agar tetap seimbang mengambil sudut depan dan belakang.
Sebagai contoh saja, mesin cat dengan semprotan tipis horizontal, dapat memanfaatka gimbal untuk menyelaraskan sapuan cat. Ini skala lebih besar, seperti sistem pengecatan otomatis.
Jadi ini hanya alat untuk mempertahankan sudut dari sebuah servo agar tetap stabil ke satu bidang.

Untuk program dapat di download ke
+ hackster.io/suk_/makeshift-gimbal-018163

Program aslinya dirancang untuk 2 servo motor, untuk kestabilan kiri kanan dan atas bawah / sudut vertikal.
Demo video diatas untuk 1 axis dan mengambil pin Servo 4, untuk kestabilan gerakan vertikal

Program dapat dilihat dibawah ini.

#include <Wire.h>
#include <Servo.h>

int servoPin1 = 4;
int servoPin2 = 7;
Servo Servo1;
Servo Servo2;
//Gyro Variables
float elapsedTime, time, timePrev;        //Variables for time control
int gyro_error=0;                         //We use this variable to only calculate once the gyro data error
float Gyr_rawX, Gyr_rawY, Gyr_rawZ;     //Here we store the raw data read
float Gyro_angle_x, Gyro_angle_y;         //Here we store the angle value obtained with Gyro data
float Gyro_raw_error_x, Gyro_raw_error_y; //Here we store the initial gyro data error
//Acc Variables
int acc_error=0;                         //We use this variable to only calculate once the Acc data error
float rad_to_deg = 180/3.141592654;      //This value is for pasing from radians to degrees values
float Acc_rawX, Acc_rawY, Acc_rawZ;    //Here we store the raw data read
float Acc_angle_x, Acc_angle_y;          //Here we store the angle value obtained with Acc data
float Acc_angle_error_x, Acc_angle_error_y; //Here we store the initial Acc data error
float Total_angle_x, Total_angle_y;

void setup() {
  Servo1.attach(servoPin1);
  Servo2.attach(servoPin2);
  Servo1.write(90);

  Servo2.write(90);
  Wire.begin();                          
  Wire.beginTransmission(0x68);                       
  Wire.write(0x6B);                      
  Wire.write(0x00);
  Wire.endTransmission(true);            
  //Gyro config
  Wire.beginTransmission(0x68);          
  Wire.write(0x1B);                      
  Wire.write(0x10);                     
  Wire.endTransmission(true);            
  //Acc config
  Wire.beginTransmission(0x68);          
  Wire.write(0x1C);                      
  Wire.write(0x10);                      
  Wire.endTransmission(true);

  Serial.begin(9600);                    
  time = millis();                       

  if(acc_error==0)
  {
    for(int a=0; a<200; a++)
    {
      Wire.beginTransmission(0x68);
      Wire.write(0x3B);                      
      Wire.endTransmission(false);
      Wire.requestFrom(0x68,6,true);        
     
      Acc_rawX=(Wire.read()<<8|Wire.read())/4096.0 ;
      Acc_rawY=(Wire.read()<<8|Wire.read())/4096.0 ;
      Acc_rawZ=(Wire.read()<<8|Wire.read())/4096.0 ;

     
      /*---X---*/
      Acc_angle_error_x = Acc_angle_error_x + ((atan((Acc_rawY)/sqrt(pow((Acc_rawX),2) + pow((Acc_rawZ),2)))*rad_to_deg));
      /*---Y---*/
      Acc_angle_error_y = Acc_angle_error_y + ((atan(-1*(Acc_rawX)/sqrt(pow((Acc_rawY),2) + pow((Acc_rawZ),2)))*rad_to_deg));
     
      if(a==199)
      {
        Acc_angle_error_x = Acc_angle_error_x/200;
        Acc_angle_error_y = Acc_angle_error_y/200;
        acc_error=1;
      }
    }
  }//end of acc error calculation  

  if(gyro_error==0)
  {
    for(int i=0; i<200; i++)
    {
      Wire.beginTransmission(0x68);            
      Wire.write(0x43);                       
      Wire.endTransmission(false);
      Wire.requestFrom(0x68,4,true);           
        
      Gyr_rawX=Wire.read()<<8|Wire.read();    
      Gyr_rawY=Wire.read()<<8|Wire.read();
  
      /*---X---*/
      Gyro_raw_error_x = Gyro_raw_error_x + (Gyr_rawX/32.8);
      /*---Y---*/ 
     
      Gyro_raw_error_y = Gyro_raw_error_y + (Gyr_rawY/32.8);  
      \
      if(i==199)
      {
        Gyro_raw_error_x = Gyro_raw_error_x/200;
        Gyro_raw_error_y = Gyro_raw_error_y/200;

        gyro_error=1;
      }
    }
  }//end of gyro error calculation  
}//end of setup void


void loop() {
  timePrev = time;                       
  time = millis();                       
  elapsedTime = (time - timePrev) / 1000;
  //////////////////////////////////////Gyro read/////////////////////////////////////

    Wire.beginTransmission(0x68);            
    Wire.write(0x43);                      
    Wire.endTransmission(false);
    Wire.requestFrom(0x68,4,true);          
       
    Gyr_rawX=Wire.read()<<8|Wire.read();    
    Gyr_rawY=Wire.read()<<8|Wire.read();
   
    /*---X---*/
    Gyr_rawX = (Gyr_rawX/32.8) - Gyro_raw_error_x; // 0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L)
    /*---Y---*/
    Gyr_rawY = (Gyr_rawY/32.8) - Gyro_raw_error_y;  //0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L)
      
    /*---X---*/
    Gyro_angle_x = Gyr_rawX*elapsedTime;
    /*---X---*/
    Gyro_angle_y = Gyr_rawY*elapsedTime;
 
  //////////////////////////////////////Acc read/////////////////////////////////////
  Wire.beginTransmission(0x68);    
  Wire.write(0x3B);                
  Wire.endTransmission(false);     
  Wire.requestFrom(0x68,6,true);   
  Acc_rawX=(Wire.read()<<8|Wire.read())/4096.0 ;
  Acc_rawY=(Wire.read()<<8|Wire.read())/4096.0 ;
  Acc_rawZ=(Wire.read()<<8|Wire.read())/4096.0 ;
 
 /*---X---*/
 Acc_angle_x = (atan((Acc_rawY)/sqrt(pow((Acc_rawX),2) + pow((Acc_rawZ),2)))*rad_to_deg) - Acc_angle_error_x;
 /*---Y---*/
 Acc_angle_y = (atan(-1*(Acc_rawX)/sqrt(pow((Acc_rawY),2) + pow((Acc_rawZ),2)))*rad_to_deg) - Acc_angle_error_y;   
 //////////////////////////////////////Total angle and filter/////////////////////////////////////
 /*---X axis angle---*/
 Total_angle_x = 0.98 *(Total_angle_x + Gyro_angle_x) + 0.02*Acc_angle_x;
 /*---Y axis angle---*/
 Total_angle_y = 0.98 *(Total_angle_y + Gyro_angle_y) + 0.02*Acc_angle_y;
 Serial.print("Xº: ");

 Serial.print(Total_angle_x);
 Serial.print("   ");
 Serial.print("Yº: ");
 Serial.print(Total_angle_y);
 Serial.println(" ");
  Servo1.write(Total_angle_x + 45);
  Servo2.write(Total_angle_y + 90);
}