Arduino Tutorial : Analog Input Potentiometer

Pada tutorial arduino kali ini kita akan masuk pada pembelajaran mengenai cara membaca data analog tegangan pada pin input analog arduino. Adapun arduino yang digunakan pada percobaan kali ini menggunakan Arduino Uno R3 dimana mikrokontroler ini memiliki 6 buah pin Analog Input dengan nama pin A0 - A5.

Pada pin analog A0 - A5 dapat diberikan tegangan antara 0 s.d 5 vdc. Pin ini merupakan pin Analog to Digital Converter atau ADC pada ATmega, tegangan 0 s.d 5 vdc akan diubah menjadi data integer 0 s.d 1023 atau 10 bit.

Langsung saja kita mulai experimen penggunaan Analog Input pada arduino. Adapun komponen yang diperlukan pada experimen ini adalah sebagai berikut.

• 1x Arduino Uno R3 Board
• 1x Breadboard
• 1x Potentiometer
• 1x LED or built in LED pin 13
• Jumper Wires

Wiring Diagram

Wiring explanation

Satu buah LED terhubung dengan pin 13 arduino. note: jika tanpa menggunakan led tambahan juga sudah bisa melakukan percobaan ini dikarenakan pada pin 13 sudah ada built in led yang akan menyala sesuai dengan kondisi pin tersebut.

Sebuah potensiometer (variable resistor) yang terhubung pada pin analog A0. Dimana pada saat potensio diputar maka tegangan yang masuk pada pin analog arduino akan berubah-ubah. note: nilai resistansi potensio bebas, semakin besar nilai resistansi maka range perubahan nilai akan lebih lebar.

Sketch Arduino

int potentioPin = A0; // memilih pin analog yang digunakan (A0 - A5)
int ledPin = 13;      // memilih pin untuk output LED
int analogValue = 0;  // variabel untuk pembacaan data analog

void setup() {
  Serial.begin(9600); // inisisalisai serial monitor
  pinMode(ledPin, OUTPUT); // inisialisali pin sebagai output (LED)
}

void loop() {
  analogValue = analogRead(potentioPin); // membaca data analog pada dan di masukkan pada variabel "analog value"
  // menampilkan data analog pada serial monitor
  Serial.print("Analog value : ");
  Serial.println(analogValue);
  
  digitalWrite(ledPin, HIGH); // menghidupkan LED
  delay(analogValue); // waktu tunda (sesuai dengan nilai analog)
  digitalWrite(ledPin, LOW);  // mematiakan LED
  delay(analogValue); // waktu tunda (sesuai dengan nilai analog)
}

Silahkan buka Serial Monitor untuk melihat nilai analog dari potensiometer.

Sketch explanation

• Pada baris 1 s.d 4 merupakan inisialisasi variabel global.
• Pada baris 11 terdapat sintaks analogRead(potentioPin) yang merupakan perintah untuk merubah nilai tegangan 0 s.d 5 volt ke nilai analog 0 s.d 1023, artinya ketika potensio diputar hingga resitansi tertinggi maka nilai tegangan akan menyentuh 0 volt dan nilai analog akan mendakati nilai terendah, sedangkan ketika potensio diputar pada resistansi rendah maka nilai tegangan mendekati 5 volt dan nilai analog mendekati nilai tertinggi nya.
• Pada baris 16 s.d 19 merupakan perintah untuk menghidupkan led dengan kondisi blink  yang menyesuaikan dengan nilai analog yang terbaca, jadi ketika nilai analog rendah maka kecepatan kedip led akan cepat dan kebalikannya ketika nilai analog besar maka led akan berkedip lebih lambat itu dipengaruhi oleh kondisi delay yang diberikan mengikuti nilai analog.

Jika ada ingin berdiskusi silahkan tinggalkan di kolom komentar, thank you and happy for your experiment..

Arduino Tutorial : Digital Input Output Arduino [LED dan Push Button]

Pada tutorial arduino kali ini kita akan belajar tentang cara kerja pin arduino pada mode input, input pullup dan output. Pada tutorial arduino ini kita menggunakan Arduino Uno, arduino uno memiliki sebanyak 14 pin digital input-output yaitu pada pin 0 sd 13.

Jadi setiap kita akan akan menggunakan pin digital arduino sebagai input maupun sebagai output, terlebih dahulu kita harus mengatur mode pin tersebut. Mode pin ini diatur pada void setup() dengan menggunakan sintaks pinMode(pin, mode). Berikut kita bahas setiap mode input output pada arduino.

Mode Input High Impedance

Sintaks : pinMode(pin, INPUT);

Mode input high impedance ini merupakan mode bawaan atau default pin arduino. Pada mode ini seolah-olah terdapat resistor 100 Mega ohm dipasang seri terhadap pin. Ini berarti pada kondisi ini pin membutuh arus yang sedikit untuk merubah kondisi logika, mode ini baik digunakan untuk membaca sensor sentuh kapasitif atau membaca LED sebagai photodioda.

Mode Input Pullup
Sintaks : pinMode(pin, INPUT_PULLUP);
Pada mode ini terdapat internal resistor sebesar 20K pada chip atmega arduino yang diatur melalui program. Resistor pull-up ini diakses dengan mengatur pinMode() sebagai INPUT_PULLUP. Ini berarti berbanding terbalik dengan mode input high impedance, logika HIGH berarti kondisi off dan logika LOW berarti on.

Jadi saat menggunakan pin sebagai input pull-up, ujung lain dari perangkat komponen sensor atau sebagai contoh pada tombol harus terhubung dengan ground. Contoh digunakan tombol push button, jika tombol tidak ditekan atau kondisi terbuka maka arduino akan membaca kondisi HIGH, dan kondisi LOW saat tombol ditekan. Gambar berikut menunjukkan ilustrasi input pull-up.

Mode Output
Sintaks : pinMode(pin, OUTPUT);
Pada saat pin di set pada mode output, pin akan dalam keadaan low impedance. Ini artinya pin dapat memberikan keluaran arus yang cukup ke rangkaian lain. Pin atmega dapat menjadi source (menghasilkan arus positif) atau sink (menghasilkan arus negatif) sebesar 40 mA (milliamper) ke rangkaian lain.

Jika arus beban dari rangkaian lain melebihi arus pin atmega, berakibat bisa merusak pin, bahkan dapat merusak ic atmega tersebut. Maka dari itu untuk mengatasinya disarankan memasang resistor 470 ohm atau 1K ohm pada pin output ke rangkaian lain.

Reference arduino.cc/reference

Arduino Tutorial : Pengenalan Arduino dan Program LED Berkedip/Blink

Tulisan ini merupakan pendahuluan dari seri tutorial arduino, pada seri tutorial arduino ini akan membahas tentang bagaimana memprogram board arduino, mulai dari program dasar hingga level yang agak lanjutan mungkin 😁.

Karena ini merupakan pendahuluan, ada baiknya kita bahas sedikit mengenai Arduino ini dulu. Jadi siapa sih arduino itu? mengapa saya katakan siapa, ya karena Arduino merupakan sebuah nama perusahaan perangkat keras dan perangkat lunak yang bersifat open-source.

Jadi perusaan ini mengembangkan berbagai macam perangkat keras mikrokontroler mulai dari Entry Level hingga yang bisa digunakan untuk project Internet of Things, untuk jenis-jenis arduino dapat dilihat di website resmi Arduino.

Berikutnya bagian perangkat lunaknya yaitu Arduino IDE (Integrated Development Environment) merupakan perangkat lunak atau software yang digunakan untuk melakukan pemrograman pada board mikrokontroler arduino. Software ini bisa di download gratis melalui website resmi Arduino.

Arduino IDE ini berguna sebagai text editor untuk membuat, mengedit, melakukan verifikasi hingga memasukkan kode program ke board Arduino. Untuk melakukan debugging, dengan software arduino ini juga bisa dilakukan menggunakan usb serial komunikasi, fitur ini dinamakan serial monitor.

Oke, mungkin itu sedikit pembahasan tentang arduino. Kita langsung masuk saja pada tutorial pertama yaitu membuat led hidup berkedip atau led blink.

Komponen yang dibutuhkan

• Boad Arduino
• Papan Breadboard
• Resistor 330 ohm
• LED
• Kabel Jumper

Rangkaian Electrical/Wiring

Pin digital D13 arduino dihubungkan dengan kaki anoda led dan kaki katoda diberi tegangan negatif dengan tahanan resistor sebesar 330 ohm.

Sketch Program LED Blink

const int LED = 13;
void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  digitalWrite(LED, HIGH);
  delay(1000);
  digitalWrite(LED, LOW);
  delay(1000);
}

Setelah program berhasil di upload ke board arduino, maka led akan berkedip setiap satu detik, untuk mengatur waktu tundanya dengan mengganti nilai delay() dengan satuan milidetik.

Line Follower Robot [Type Arduino Nano]

Line follower robot versi ini di rancang menggunakan Arduino Nano sebagai mikrokontroler utamanya, sebelumnya sudah pernah juga dibahas mengenai robot line follower yang menggunakan kendali pid, yang ingin tahu bagaimana penerapan kontrol pid mungkin bisa dibaca terlebih dahulu Line Follower Robot Using PID Control.

Selanjutnya ini merupakan line follower versi lanjutan yang dilengkapi dengan fitur tambahan tentunya, line follower versi ini menggunakan mikrokontroler arduino jadi sangat mungkin untuk kita melakukan pengembangan pada sisi pemrograman dikarenakan dengan Arduino IDE sudah sangat dipermudah untuk melakukan akses pin input outputnya, selain itu robot ini juga dilengkapi dengan LCD 16x2 untuk mempermudah dalam penambahan fitur dengan dilengakapi 4 push button sebagai tombol navigasi menu untuk malakukan pengaturan pada robot. Robot ini menggunakan 14 sensor photo dioda serta menggunakan kontrol PID yang membuat pergerakan robot menjadi lebih responsif mengikuti garis.
Spesifikasi

• Mikrokontroler Arduino Nano
• 14 sensor
• LCD 16x2
• 4 button setting
• Dual channel H-Bridge Driver Motor (L293D)
• Motor DC 12 V
• Battery LiPo 3S (12V)
• Ext. [1]. Stick controller/Bluetooth (Control with android) [2]. Flame sensor [3]. Motor DC fan [4]. Motor servo

Fitur Line Follower Type Nano

• Menggunakan PID kontroler
• Setting kalibrasi sensor (auto scan)
• Setting kecepatan
• Mode normal
• Mode manual Joystick
• Mode manual Bluetooth (aplikasi android)
• Mode pemadam api (line follower pemdam api manual/auto)

Gallery LFRobot Type Nano

Previous Next

Wall Follower Robot dengan Kendali PID

Kali ini saya akan membagikan mengenai robot lagi nih, yah robot.. namun masih seperti robot-robot sebelumnya yang sudah pernah saya tulis di blog ini yaitu masih mobile robot atau robot yang masih menggunakan roda sebagai penggeraknya dan masih robot follower juga hehe... namun berbeda dengan yang sebelumnya untuk robot light follower bisa dibaca disini.

Jadi robot yang akan dibahas kali ini adalah Wall Follower Robot atau robot pengikut dinding, artinya robot ini dapat berjalan dengan baik mengikuti dinding atau lintasan seperti labirin dan diharapkan tanpa menabrak tentunya. Cara kerja dari robot ini dengan membaca dan mendeteksi penghalang atau dinding terhadap robot dengan menggunakan sensor jarak, robot akan mengatur jaraknya terhadap dinding agar tetap konstan dengan cara robot akan bergerak jika terjadi perubahan jaraknya untuk kemudian menyesuaikan lagi secara terus menerus.

Rancangan Mekanik Wall Follower Robot

Rancangan Elektrikal

Tampilan Hasil Rancangan Wall Follower Robot

Wall Follower Dengan PID

Untuk menghasilkan pergerakan robot yang responsif, robot ini menggunakan kendali PID, pada artikel ini saya tidak akan membahas apa itu PID atau pengertian dari kendali PID, untuk lebih jelas mengenai PID ini mungkin bisa dibaca melalui jurnal-jurnal yang berkaitan dengan sistem kendali PID karena disini hanya akan dibahas penerapan kendali PID tersebut pada robot wall follower.

Pada robot ini digunakan 3 buah sensor jarak yang diletakkan pada robot, satu sensor diletakkan serong kiri, satu serong kanan dan satu sensor diletakkan menghadap depan. Jadi kendali pid nya bagaimana? oke.. jadi pada robot ini hanya satu sensor saja yang di pid kan yaitu bisa sensor kiri maupun kanan, artinya yang menjadi feedback untuk pengendalian pid ini didapat dari sensor jarak kiri ataupun kanan, jadi skenarionya gini.. sensor mana (kiri atau kanan) yang paling mendekati dinding maka jarak dari sensor tersebut yang digunakan untuk pengendalian pid, agar robot tidak menabrak depan maka itu fungsi dari sensor yang menghadap depan, untuk kondisi ini tidak masuk ke pengendalian pid.

Diagram Blok Kendali PID Pada Wall Follower Robot

Setpoint pada robot ini saya atur 10 cm yang artinya robot akan mempertahankan posisinya di 10 cm (kondisi ideal robot) dari dinding, caranya robot akan terus bergerak ke kiri maupun ke kanan jika kondisi tidak ideal dimana akan ada nilai error, pada kondisi error output PID akan mengeluarkan hasil kendalinya sesuai dengan besarnya nilai error yang terjadi dan kemudian akan di kalkulasikan denga nilai base PWM yang menjadi kecepatan PWM motor kiri maupun kanan, jika kondisi robot ideal atau jarak sesuai dengan setpoint maka robot akan bergerak lurus.

Ilustrasi Kendali PID Pada Wall Follower Robot

Dalam menentukan nilai parameter kendali PID bisa dilakukan dengan cara try and error atau dengan cara coba-coba namun dangan cara tersebut akan lebih sulit dan membutuhkan waktu yang lama untuk mendapatkan hasil kendali yang stabil, maka dari itu dalam menentukan nilai yang tepat untuk parameter aksi kontrol proporsional, integral dan derivative bisa dilakukan dengan melakukan tuning dengan metode Ziegler-Nichols sama seperti proses tuning yang di lakukan pada robot line follower, bisa di baca disini.

Desain Kendali Suhu Ruangan Berbasis Logika Fuzzy [Room Temperature Control Based on Fuzzy]

Kali ini mau berbagi lagi nih tentang proyek elektronika.. artikel yang akan dibagikan kali ini mengenai kendali fuzzy yang merupakan bagian dari sebuah kecerdasan buatan atau Artificial Intelligence, proyek ini merupakan proyek akhir semester mata kuliah kecerdasan buatan saya, adapun penerapan kendali fuzzy kali ini pada proyek sistem kendali suhu ruangan dengan inputan suhu dan banyaknya orang dimana outputnya adalah kecepatan kipas, proyek ini di implementasikan dalam bentuk prototype.

Apa itu Logika Fuzzy?

Akan dijelaskan sedikit pengertian mengenai logika fuzzy yang merupakan suatu cabang ilmu Artificial Intellegence atau kecerdasan buatan, yaitu suatu pengetahuan yang membuat komputer dapat meniru kecerdasan manusia sehingga diharapkan komputer dapat melakukan hal-hal yang apabila dikerjakan manusia memerlukan kecerdasan. Umumnya diterapkan pada masalah-masalah yang mengandung unsur ketidakpastian, ketidaktepatan, dan sebagainya (dikutip dari wikipedia).

Perancangan Sistem Kendali Suhu Ruangan

Sistem kendali suhu ruangan ini dirancang dalam bentuk prototype. Sistem dirancang agar dapat mengendalikan suhu pada suatu ruangan, adapun parameter sebagai pengendali adalah kondisi suhu pada ruangan dan banyaknya orang dalam ruangan tersebut, digunakan kipas angin sebagai pengendali suhu ruangan tersebut.

Komponen yang dibutuhkan

1x Arduino Uno

1x Sensor Suhu (DHT11)

2x Modul Sensor Infrared

2x Kipas DC

1x LCD + i2C

1x Driver Motor DC

Kabel Jumper Secukupnya

Berikut ini rangkaian elektrikalnya

Perancangan Sistem Fuzzy
Proses pembuatan sistem fuzzy terdapat beberapa tahapan alur proses untuk mendapatkan keluaran fuzzy mulai dari fuzzifikasi hingga defuzzifikasi.

Pada perancangan sistem kendali fuzzy ini terdapat beberapa bagian terpenting, yaitu sebagai berikut:

Fuzzifikasi : Pada proses fuzzifikasi, inputan crisp akan dirubah menjadi variabel linguistic (variabel Fuzzy).

Inferensi (Aturan Dasar) : Proses inferensi merupakan proses untuk mendapatkan keluaran dari rule set yang dibuat, ini merupakan inti dari proses fuzzy.

Defuzzifikasi : Proses defuzzifikasi merupakan proses terakhir dalam sistem Fuzzy. Proses ini merupakan proses perubahan data input yang telah dimasukkan dalam himpunan-himpunan Fuzzy untuk mendapatkan kembali bentuk tegasnya (Crisp). 

Baiklah.. selanjutnya masuk pada pembahasan utama, yaitu proses kendali fuzzy pada proyek kendali suhu ruangan ini, untuk tahapan akan dijelaskan adalah proses fuzzifikasi, proses inferensi dan proses defuzzifikasi, langsung saja untuk penjelasan tahap - tahap nya sebagai berikut :

Proses Fuzzifikasi
Pada proses ini dibuat beberapa fungsi keangotaan (membership function), yang digunakan sebagai input adalah membership fungsi suhu dan banyaknya orang dalam ruangan. Sedangkan output adalah persentase 0% - 100% pwm yang mengontrol kecepatan motor kipas.

Jika proses fuzzifikasi diterapkan pada program sebagai berikut :

Diatas merupakan program untuk proses fuzzifikasi pada mikrokontroler Arduino, pada fungsi hitung_member merupakan fungsi rumus perhitungan drajat keangotaan dengan menggunakan rumus kurva naik-turun. Pada fungsi fuzzifikasi merupakan proses fuzzifikasinya yaitu menghitung dan memasukkan nilai batas - batas untuk inputan suhu dan banyaknya orang dengan memanggil fungsi hitung_member.

Proses Inferensi dan Defuzzifikasi

Metode defuzzifikasi yang digunakan adalah centroid atau center of area (COA). Dimana nilai tegas outputnya diperoleh berdasarkan titik berat dari kurva hasil proses pengambilan keputusan. Dengan menggunakan persamaan sebagai berikut:

Nilai Min didapat dengan mengambil nilai terendah dari masing - masing keanggotaan antara suhu dan banyak orang.

Untuk mencari center of area (COA) dilakukan dengan menjumlahkan perkalian Nilai Minimum dengan bobot keanggotaan keluaran kecepatan kipas kemudian dibagi dengan jumlah Nilai Minimun. Jika diterapkan pada program sebagai berikut :

Program tersebut merupakan program untuk proses inferensi dan defuzzifikasi. Proses ini untuk mendapatkan keluaran dari rule set yang dibuat, inferensi kali ini digunkan metode mamdani atau disebut dengan metode max – min, variable array fuzzy_set merupakan nilai bobot sesuai dengan rule yang dibuat.

Digunakan fungsi max untuk mengambil nilai tertinggi dan min untuk mengambil nilai terkecilnya. Untuk proses fuzzifikasi digunakan metode Centre Of Area (COA) dan hasil dari fuzzifikasi ini merupakan keluaran untuk pwm kipas. 

Pada Program looping merupakan program untuk menjalankan semua fungsi-fungsi yang buat. Pada gambar diatas terdapat fungsi pembacan sensor infrared dan pemcaan sensor suhu yang dilakukan update setiap 2 detik, fungsi fuzzifikasi,defuzzifikasi juga dilakukan pada program looping serta menghasilkan output 0 hingga 100 yang akan dilakukan mapping dari 0 hingga 255 untuk pwm kipas, setelah itu dilakukan pemanggilan fungsi untuk menggerakkan kipas.

Program Arduino lengkapnya dapat di copy dibawah ini

/********************************
  Room Temperature Control System
  Based On Fuzzy Logic
  www.muhilham.com
  2018
*********************************/

#include "liquidcrystal_i2c.h"
LiquidCrystal_I2C lcd(0x3F, 16, 2);
#include "DHT.h"

DHT dht(4, DHT11);
int sen_in, sen_out, offset_sen_in, offset_sen_out; // variabel sensor infrared
boolean detect_in = false, detect_out = false;

int count;
float suhu,
      uMember,
      uDingin, uSejuk, uNormal, uPanas, uSangatPanas,
      uSangatSedikit, uSedikit, uSedang, uBanyak, uSangatBanyak,
      N_suhu[5], N_orang[5], kondisiSuhu, kondisiOrang, Min[25],
      Keluaran, Kecepatan;
String OutputFuzzy;

const int PWM_KIPAS   = 5,
          P1_KIPAS    = 6,
          P2_KIPAS    = 7,
          PWM_EXHAUST = 9,
          P1_EXHAUST  = 8,
          P2_EXHAUST  = 10;

long lastTime_readSen = 0, lastTime_LCD = 0;
int state_LCD = 1;

void setup() {
  Serial.begin(9600);
  lcd.begin();
  dht.begin();
  for (int i = 0; i <= 1; i++) {
    pinMode(i, INPUT);
  }
  for (int i = 5; i <= 10; i++) {
    pinMode(i, OUTPUT);
  }

  sen_in = analogRead(A0);
  sen_out = analogRead(A1);
  offset_sen_in = sen_in - 70;   // sample sensor masuk
  offset_sen_out = sen_out - 70; // sample sensor keluar
  count = 0;
  temp()
}

void loop() {
  sensor_count();

  fuzzifikasi();
  defuzzifikasi();
  Output();
  Kecepatan = map(Keluaran, 0, 100, 0, 255);
  driveKipas_N_Exhaust(Kecepatan);
}


// -----------------------------------------------------------
// Read DHT Function
float temp() {
  float temp = dht.readTemperature();
  // Check if any reads failed and exit early (to try again).
  if (isnan(temp)) {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }

  return temp;
}
// #END Read DHT Function -------------------------------------


void sensor_count() {
  sen_in = analogRead(A0);
  sen_out = analogRead(A1);

  if (sen_in > offset_sen_in) {
    detect_in = false;
  }
  else if (sen_in < offset_sen_in && detect_in == false) {
    count++;
    detect_in = true;
    if (count >= 40)count = 40;
  }

  if (sen_out > offset_sen_out) {
    detect_out = false;
  }
  else if (sen_out < offset_sen_out && detect_out == false) {
    count--;
    detect_out = true;
    if (count < 0)count = 0;
  }
}

void driveKipas_N_Exhaust(float Kecepatan) {
  digitalWrite(P1_KIPAS, LOW);
  digitalWrite(P2_KIPAS, HIGH);
  analogWrite(PWM_KIPAS, Kecepatan);
  digitalWrite(P1_EXHAUST, LOW);
  digitalWrite(P2_EXHAUST, HIGH);
  analogWrite(PWM_EXHAUST, Kecepatan);
}

void hitung_member(int pilih, float Nilai, float A, float B, float C) {
  switch (pilih) {
    case 1:
      if ((Nilai >= A) && (Nilai <= B)) uMember = 1;
      if ((Nilai > B) && (Nilai < C)) uMember = (C - Nilai) / (C - B);
      if (Nilai >= C) uMember = 0;
      break;
    case 2:
      if ((Nilai <= A) || (Nilai >= C)) uMember = 0;
      if ((Nilai > A) && (Nilai < B)) uMember = (Nilai - A) / (B - A);
      if ((Nilai > B) && (Nilai < C)) uMember = (C - Nilai) / (C - B);
      if (Nilai == B) uMember = 1;
      break;
    case 3:
      if (Nilai <= A) uMember = 0;
      if ((Nilai > A) && (Nilai < B)) uMember = (Nilai - A) / (B - A);
      if (Nilai >= B) uMember = 1;
      break;
  }
}

void fuzzifikasi() {
  // Suhu
  uMember = 0;
  hitung_member(1, temp(), 0, 24, 26);
  uDingin = uMember;
  hitung_member(2, temp(), 24, 26, 29);
  uSejuk = uMember;
  hitung_member(2, temp(), 26, 29, 32);
  uNormal = uMember;
  hitung_member(2, temp(), 29, 32, 35);
  uPanas = uMember;
  hitung_member(3, temp(), 32, 35, 35);
  uSangatPanas = uMember;

  // Banyak Orang
  uMember = 0;
  hitung_member(1, count, 0, 5, 10);
  uSangatSedikit = uMember;
  hitung_member(2, count, 5, 10, 20);
  uSedikit = uMember;
  hitung_member(2, count, 10, 20, 30);
  uSedang = uMember;
  hitung_member(2, count, 20, 30, 40);
  uBanyak = uMember;
  hitung_member(3, count, 30, 40, 40);
  uSangatBanyak = uMember;
}

//int fuzzy_set[5][5] = {
//  //Cold|Cool|Nor|Hot|Vhot
//  {20, 20, 20, 60, 80},   //| Vlow
//  {20, 40, 20, 60, 80},   //| Low
//  {40, 40, 60, 80, 100},  //| Medium
//  {40, 60, 80, 100, 100}, //| High
//  {60, 80, 100, 100, 100} //| Very high
//};

//20 = Vslow, 40 = Slow, 60 = Med, 80 = Fast, 100 = Vfast
int fuzzy_set[5][5] = {
  //|vLow|Low|Med|High|vHigh
  {20, 20, 40,  40,  60},  //| Cold
  {20, 40, 40,  60,  80},  //| Cool
  {40, 40, 60,  80,  100}, //| Normal
  {60, 60, 80,  100, 100}, //| Hot
  {80, 80, 100, 100, 100}  //| Very hot
};

void defuzzifikasi() {
  float pembil = 0, penyeb = 0, centre_of_area = 0;
  N_suhu[5] = {};
  N_orang[5] = {};

  for (int set = 0; set < 25;) {
    for (int i = 0; i < 5; i++) {
      for (int j = 0; j < 5; j++) {
        float data_uSuhu[5] = {uDingin, uSejuk, uNormal, uPanas, uSangatPanas};
        N_suhu[i] = data_uSuhu[i];
        float data_uOrang[5] = {uSangatSedikit, uSedikit, uSedang, uBanyak, uSangatBanyak};
        N_orang[j] = data_uOrang[j];

        kondisiSuhu = max(N_suhu[i], kondisiSuhu);
        kondisiOrang = max(N_orang[j], kondisiOrang);

        /* Metode COA (Centre Of Area)*/
        min[set] = min(N_suhu[i], N_orang[j]);
        pembil  += Min[set] * fuzzy_set[i][j];
        penyeb  += Min[set];
        delay(5);
        set ++;
      }
    }
  }
  centre_of_area = pembil / penyeb;
  Keluaran = centre_of_area;
}

void basis_Aturan_output() {
  if (kondisiSuhu == uDingin && kondisiOrang == uSangatSedikit)OutputFuzzy = "Vslow";
  else if (kondisiSuhu == uDingin && kondisiOrang == uSedikit)OutputFuzzy = "Vslow";
  else if (kondisiSuhu == uDingin && kondisiOrang == uSedang)OutputFuzzy = "Slow";
  else if (kondisiSuhu == uDingin && kondisiOrang == uBanyak)OutputFuzzy = "Slow";
  else if (kondisiSuhu == uDingin && kondisiOrang == uSangatBanyak)OutputFuzzy = "Med";

  else if (kondisiSuhu == uSejuk && kondisiOrang == uSangatSedikit)OutputFuzzy = "Vslow";
  else if (kondisiSuhu == uSejuk && kondisiOrang == uSedikit)OutputFuzzy = "Slow";
  else if (kondisiSuhu == uSejuk && kondisiOrang == uSedang)OutputFuzzy = "Slow";
  else if (kondisiSuhu == uSejuk && kondisiOrang == uBanyak)OutputFuzzy = "Med";
  else if (kondisiSuhu == uSejuk && kondisiOrang == uSangatBanyak)OutputFuzzy = "Fast";

  else if (kondisiSuhu == uNormal && kondisiOrang == uSangatSedikit)OutputFuzzy = "Slow";
  else if (kondisiSuhu == uNormal && kondisiOrang == uSedikit)OutputFuzzy = "Slow";
  else if (kondisiSuhu == uNormal && kondisiOrang == uSedang)OutputFuzzy = "Med";
  else if (kondisiSuhu == uNormal && kondisiOrang == uBanyak)OutputFuzzy = "Fast";
  else if (kondisiSuhu == uNormal && kondisiOrang == uSangatBanyak)OutputFuzzy = "Vfast";

  else if (kondisiSuhu == uPanas && kondisiOrang == uSangatSedikit)OutputFuzzy = "Med";
  else if (kondisiSuhu == uPanas && kondisiOrang == uSedikit)OutputFuzzy = "Med";
  else if (kondisiSuhu == uPanas && kondisiOrang == uSedang)OutputFuzzy = "Fast";
  else if (kondisiSuhu == uPanas && kondisiOrang == uBanyak)OutputFuzzy = "Vfast";
  else if (kondisiSuhu == uPanas && kondisiOrang == uSangatBanyak)OutputFuzzy = "Vfast";

  else if (kondisiSuhu == uSangatPanas && kondisiOrang == uSangatSedikit)OutputFuzzy = "Fast";
  else if (kondisiSuhu == uSangatPanas && kondisiOrang == uSedikit)OutputFuzzy = "Fast";
  else if (kondisiSuhu == uSangatPanas && kondisiOrang == uSedang)OutputFuzzy = "Vfast";
  else if (kondisiSuhu == uSangatPanas && kondisiOrang == uBanyak)OutputFuzzy = "Vfast";
  else if (kondisiSuhu == uSangatPanas && kondisiOrang == uSangatBanyak)OutputFuzzy = "Vfast";
}

void Output() {
  //uMember_suhu_count();
  basis_Aturan_output();
  Tampil_Serial();
  Tampil_LCD();
}

void Tampil_Serial() {
  //Tampil Serial
  Serial.print(" Temp : ");
  Serial.print(temp());
  Serial.print(" *C ");
  Serial.print(" ");
  tampil_member_suhu();
  if (kondisiSuhu == N_suhu[0])Serial.print("Cold");
  else if (kondisiSuhu == N_suhu[1])Serial.print("Cool");
  else if (kondisiSuhu == N_suhu[2])Serial.print("Normal");
  else if (kondisiSuhu == N_suhu[3])Serial.print("Hot");
  else if (kondisiSuhu == N_suhu[4])Serial.print("Very Hot");

  Serial.print(" | Count : ");
  Serial.print(count);
  Serial.print(" ");
  tampil_member_count();
  if (kondisiOrang == N_orang[0])Serial.print("Very Low");
  else if (kondisiOrang == N_orang[1])Serial.print("Low");
  else if (kondisiOrang == N_orang[2])Serial.print("Medium");
  else if (kondisiOrang == N_orang[3])Serial.print("High");
  else if (kondisiOrang == N_orang[4])Serial.print("Very High");

  Serial.print(" | ");
  if (OutputFuzzy == "Vslow")     Serial.print("Fan : Very Slow");
  else if (OutputFuzzy == "Slow") Serial.print("Fan : Slow");
  else if (OutputFuzzy == "Med")  Serial.print("Fan : Medium");
  else if (OutputFuzzy == "Fast") Serial.print("Fan : Fast");
  else if (OutputFuzzy == "Vfast")Serial.print("Fan : Very Fast");
  Serial.print(" LV : ");
  Serial.print(Keluaran);
  Serial.print("%");
  Serial.print(" PWM : ");
  Serial.print(Kecepatan);
  Serial.println();
}

void Tampil_LCD() {
  lcd.backlight();
  if (millis() - lastTime_LCD > 5000) {
    state_LCD = 1;
    lastTime_LCD = millis();
  }
  if (millis() > lastTime_LCD + 2500) {
    state_LCD = 2;
  }

  if (state_LCD == 1) {
    lcd.setCursor (0, 0);
    lcd.print("Temp:");
    lcd.print((int)temp());
    lcd.print("C ");
    if (kondisiSuhu == N_suhu[0])lcd.print("   Cold");
    if (kondisiSuhu == N_suhu[1])lcd.print("   Cool");
    if (kondisiSuhu == N_suhu[2])lcd.print(" Normal");
    if (kondisiSuhu == N_suhu[3])lcd.print("    Hot");
    if (kondisiSuhu == N_suhu[4])lcd.print("VeryHot");

    lcd.setCursor (0, 1);
    lcd.print("Cont:");
    lcd.print((int)count);
    lcd.print(" ");
    lcd.setCursor (7, 1);
    if (kondisiOrang == N_orang[0])lcd.print("  VeryLow");
    if (kondisiOrang == N_orang[1])lcd.print("      Low");
    if (kondisiOrang == N_orang[2])lcd.print("   Medium");
    if (kondisiOrang == N_orang[3])lcd.print("     High");
    if (kondisiOrang == N_orang[4])lcd.print(" VeryHigh");
  }
  else if (state_LCD == 2) {
    lcd.setCursor (0, 0);
    lcd.print("  PWM: ");
    lcd.print((float)Keluaran);
    lcd.print("%   ");
    lcd.setCursor (0, 1);
    if (OutputFuzzy == "Vslow")     lcd.print("   Very Slow    ");
    else if (OutputFuzzy == "Slow") lcd.print("      Slow      ");
    else if (OutputFuzzy == "Med")  lcd.print("     Medium     ");
    else if (OutputFuzzy == "Fast") lcd.print("      Fast      ");
    else if (OutputFuzzy == "Vfast")lcd.print("   Very Fast    ");
  }
}
void uMember_suhu_count() {
  Serial.print(" Temp : ");
  Serial.print(temp());
  Serial.print(" *C ");
  Serial.print(" ");
  Serial.print("Cold:");
  Serial.print(uDingin);
  Serial.print(" Cool:");
  Serial.print(uSejuk);
  Serial.print(" Nor:");
  Serial.print(uNormal);
  Serial.print(" Hot:");
  Serial.print(uPanas);
  Serial.print(" VHot:");
  Serial.print(uSangatPanas);
  Serial.print(" ");

  Serial.print(" | Count : ");
  Serial.print(count);
  Serial.print(" ");
  Serial.print("VLow:");
  Serial.print(uSangatSedikit);
  Serial.print(" Low:");
  Serial.print(uSedikit);
  Serial.print(" Med:");
  Serial.print(uSedang);
  Serial.print(" High:");
  Serial.print(uBanyak);
  Serial.print(" VHigh:");
  Serial.println(uSangatBanyak);
}

void tampil_member_suhu() {
  //if (uDingin != 0.00) {
    Serial.print("Cold:");
    Serial.print(uDingin);
  //}
  //if (uSejuk != 0.00) {
    Serial.print(" Cool:");
    Serial.print(uSejuk);
  //}
  //if (uNormal != 0.00) {
    Serial.print(" Nor:");
    Serial.print(uNormal);
  //}
  //if (uPanas != 0.00) {
    Serial.print(" Hot:");
    Serial.print(uPanas);
  //}
  //if (uSangatPanas != 0.00) {
    Serial.print(" VHot:");
    Serial.print(uSangatPanas);
  //}
  Serial.print(" ");
}

void tampil_member_count() {
  //if (uSangatSedikit != 0.00) {
    Serial.print("VLow:");
    Serial.print(uSangatSedikit);
  //}
  //if (uSedikit != 0.00) {
    Serial.print(" Low:");
    Serial.print(uSedikit);
  //}
  //if (uSedang != 0.00) {
    Serial.print(" Med:");
    Serial.print(uSedang);
  //}
  //if (uBanyak != 0.00) {
    Serial.print(" High:");
    Serial.print(uBanyak);
  //}
  //if (uSangatBanyak != 0.00) {
    Serial.print(" VHigh:");
    Serial.print(uSangatBanyak);
  //}
  Serial.print(" ");
}

Light Follower Robot Arduino Dengan LDR

Waktu itu dapat pesanan project robot sederhana dari guru salah satu sekolah smk untuk bahan pembelajaran katanya, nah robot tersebut akan yang akan di bahas kali ini, jadi robot itu adalah light follower robot atau robot pengikut cahaya, robot ini merupakan robot yang berjenis mobile robot atau robot dengan menggunakan roda.

Light follower robot ini tidak jauh beda dengan robot line follower hanya saja perbedaannya jika line follower mengikuti track garis lain halnya dengan robot light follower ini mengkuti cahaya, artinya robot akan berjalan jika diberi cahaya pada sensor, dimana robot akan berjalan  ke arah sesuai dengan sensor mana yang terkena cahaya.

Sensor yang digunakan yaitu sensor LDR (light dependent resistor) pada robot ini menggunakan 3 sensor LDR yang dipasang di depan robot dengan menghadap depan robot, samping kanan robot dan samping kiri robot, sebagai pengendali pergerakan robot dan pemeroses siyal sensor digunakan arduino sebagai mikrokontroler robot ini.

Komponen yang dibutuhkan 

• 1x Arduino Uno
• 2x Motor DC
• 1x Driver Motor H-Bridge L298N
• 3x LDR (light dependent resistor)
• 3x Resistor 10k
• 1x Switch ON/OFF
• 1x Baterai 9V (di video menggunakan 4x baterai AA)
• Kabel secukupnya
• Chasis robot (robot ini menggunakan acrylic)
• Spacer

Rangkaian/wiring robot

Jika arah putaran motor tidak sesuai, balik kabel motor yang terhubung dengan output driver motor, untuk baterai bisa menggunakan baterai 9V atau 12V.

👉 UNTUK PEMESANAN ATAU CUSTOM PROJECT 👈

Program/coding arduino langsung copy ke software arduino dan upload ke arduino

/**************************
  light follower robot v2
  www.muhilham.com
  08/01/2020
***********************/

#define pin_MOTOR_DIRL 2
#define pin_MOTOR_PWML 3
#define pin_MOTOR_DIRR 4
#define pin_MOTOR_PWMR 5

#define Kec_Min -170
#define Kec_Max  220 // Max = 255

const int8_t pinSensor[3] = {A0, A1, A2}; // array pin sensor
int16_t limitSensor[3]; // array limit sensor
int16_t correction = 100; // nilai koreksi kalibrasi sensor

void setup() {
  Serial.begin(9600);
  pinMode(pin_MOTOR_DIRL, OUTPUT);
  pinMode(pin_MOTOR_PWML, OUTPUT);
  pinMode(pin_MOTOR_DIRR, OUTPUT);
  pinMode(pin_MOTOR_PWMR, OUTPUT);

  for (byte i = 0; i < 3; i++) { // kalibrasi sensor
    pinMode(pinSensor[i], INPUT);
    limitSensor[i] = analogRead(pinSensor[i]) + correction;
    if (limitSensor[i] > 1023) limitSensor[i] = 1023;
    delay(50);
  }
}

void loop() {
  Serial.print("|");
  Serial.print(limitSensor[0]);
  Serial.print("|");
  Serial.print(limitSensor[1]);
  Serial.print("|");
  Serial.print(limitSensor[2]);
  Serial.print("| |");

  Serial.print(analogRead(pinSensor[0]));
  Serial.print("|");
  Serial.print(analogRead(pinSensor[1]));
  Serial.print("|");
  Serial.print(analogRead(pinSensor[2]));
  Serial.print("| |");

  followLight();
}

void followLight() {
  int16_t sensor = BacaSensor();

  switch (sensor) {
    case 0b000 : driveMotor(0, 0); Serial.println("|  Stop"); break;        // Belok kiri
    case 0b001 : driveMotor(Kec_Max, Kec_Max / 2); Serial.println("|  Belok Kanan"); break;       // Belok kanan
    case 0b011 : driveMotor(Kec_Max / 2, Kec_Max / 3); Serial.println("|  Serong Kanan"); break;  // Serong kanan
    case 0b010 : driveMotor(Kec_Max, Kec_Max); Serial.println("|  Lurus"); break;          // Lurus
    case 0b111 : driveMotor(Kec_Max, Kec_Max); Serial.println("|  Lurus"); break;          // Lurus
    case 0b110 : driveMotor(Kec_Max / 3, Kec_Max / 2); Serial.println("|  Serong Kiri"); break;   // Serong kiri
    case 0b100 : driveMotor(Kec_Max / 2, Kec_Max); Serial.println("|  Belok Kiri"); break;        // Belok kiri
    case 0b101 : driveMotor(Kec_Max, Kec_Max); Serial.println("|  Lurus"); break;        // Belok kiri
  }
}

int16_t BacaSensor() {
  int16_t bitSensor = 0;

  for (byte i = 0; i < 3; i++) {
    if (analogRead(pinSensor[i]) > limitSensor[i]) {
      bitSensor = bitSensor | (0b100 >> i);
      Serial.print("1");
    } else Serial.print("0");
  }

  return bitSensor;
}


void driveMotor(int16_t Left, int16_t Right) {
  if (Left > 0) {
    digitalWrite(pin_MOTOR_DIRL, LOW);
  } else {
    digitalWrite(pin_MOTOR_DIRL, HIGH);
    Left = 255 + Left;
  }
  analogWrite(pin_MOTOR_PWML, Left);

  if (Right > 0) {
    digitalWrite(pin_MOTOR_DIRR, LOW);
  } else {
    digitalWrite(pin_MOTOR_DIRR, HIGH);
    Right = 255 + Right;
  }
  analogWrite(pin_MOTOR_PWMR, Right);
}

Membuat Running LED Dengan Program Menggunakan Arduino Atmega328

Sebelumnya saya sudah membuat sebuah artikel mengenai running led atau led berjalan, yang dimana pada artikel sebelumnya running led yang dibuat menggunakan IC 4017 dan IC timer NE555 atau tanpa program, artikel sebelumnya baca disini.

Pada artikel kali ini masih sama, masih  membuat running led namun perbedaan nya kali ini menggunakan arduino atau mikrokontroler atmega328 yang dimana digunakan sebuah chip yang bisa di isi dengan program/coding, program yang akan dibuat kali ini adalah membuat led tersebut menyala secara bergantian.

Karena running led yang akan dibuat dengan menggunakan program maka komponen yang digunakan berbeda dengan running led sebelumnya. Adapun komponen yang digunkan untuk membuat running led dengan program ini adalah sebagai berikut:

• Arduino Uno (digunakan sebagai downloader IC ATmega328)
• IC ATmega328/ATmega8 1x
• Dioda 1N4007 1x
• Kapasitor 22pF 2x
• Kapasitor 100n 1x
• Resistor Variabel 100k 1x
• Crystal 16.000Mhz 1x
• LED 5mm 20x
• PCB Polos

Rangkaian atau skematik running led menggunakan program sebagai berikut :

Untuk desain saya akan membuat pada pcb dimana ic atmega328/atmega8 (ic dengan bootloder arduino) nantinya diprogram pada arduino uno, setelah selesai diprogram ic yang sudah diprogram dipindahkan pada rangkaian pcb yang dibuat.

Penjelasan sedikit mengenai rangkaian, rangkian ini merupakan sistem minimun mikrokontroler dasar pada unumnya dimana digunakan crystal external dan capasitor sebagai pembangkit frekuensinya, pada pembuatan running led ini pin yang digunakan saya sesuaikan dengan pin dari arduino uno yang menggunakan ic atmega328/atmega8 untuk pin yang digunakan ada pin digital out untuk led dan pin analog in untuk mengatur kecepatan pergantian nyala led.

Untuk pinout diagram dari arduino uno dapat dilihat pada gambar berikut :

Brikut ini desain layout PCB yang saya buat dengan menggunakan software EAGLE.

Program/coding arduino silahkan langsung copy ke software arduino dan langsung upload ke  mikrokontroler.

/**************************
 Running LED
 www.muhilham.com
 14/07/2018
***********************/

const int pinLED[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int delayLED;

void setup() {
  //Serial.begin(9600);
  for (int i = 0; i < 10; i++) {
    pinMode(pinLED[i], OUTPUT);
  }
  for (int i = 0; i < 10; i++) {
    digitalWrite(pinLED[i], HIGH);
    delay(200);
  }
  for (int i = 0; i < 10; i++) {
    digitalWrite(pinLED[i], LOW);
    delay(100);
  }
}

void loop() {
  delayLed = analogRead(A0);

  for (int i = 0; i < 10; i++) {
    digitalWrite(pinLED[i], HIGH);
    delay(delayLED);
    digitalWrite(pinLED[i], LOW);
  }
  //Serial.println(delayLED);
}

Membuat Running LED Dengan IC 4017 dan Timer NE555

Setelah sekian lama tidak update dikarenakan kesibukan kuliah dan kesibukan lain diluar sana yang membuat saya tidak sempat untuk menulis ataupun membuat sesuatu yang bisa dibagikan di blog ini.

Namun pada kesempatan kali ini saya akan membagikan sedikit tentang cara membuat running LED dengan IC 4017 dan sebuah IC Timer NE555.

Sebelum masuk ke pembuatan, mari kita bahas sedikit tentang apa itu running led, jadi apasih sebenarnya running led itu?

Jika di terjemahkan dari bahasa luar negerinnya yaitu bahasa inggris running led itu merupakan led berjalan hehe.. :), yang dimaksud berjalan disini pada rangkaian terdapat beberapa led yang nantinya akan nyala bergantian secara berurutan dengan kecepatan yang dapat diatur.

Running led ini merupakan rangkaian dasar yang bisa dibuat saat ingin belajar tentang pembuatan rangkaian dan di terapkan ke PCB, biasanya proyek ini dibuat saat smk jurusan elektronika, dengan rangkaian yang cukup sederhana maka tingkat keberhasilan yang cukup besar hanya saja dibutuhkan analisa dan ketelitian. 

Adapun untuk komponen yang digunakan pun mudah di dapat ditoko komponen  elektronika tentunya, berikut ini beberapa komponen yang dibutuhkan untuk membuat running led atau led berjalan.

• Dioda 1N4007 1x
• Kapasitor 22uF/16V 1x
• Kapasitor 4.7uF/16V 1x
• Resistor 1K 1x
• Resistor 4.7K 1x
• Resistor Variabel 100K 1x
• IC 4017 1x
• IC NE555N 1x
• LED 5mm 20x

Setelah komponen sudah lengkap kita masuk ke rangkaian atau skematik running led sebagai berikut:

Sedikit penjelasan dari rangkaian digunkan 20 LED yang terhubung dengan IC 4017 merupakanjenis IC CMOS yang berupakan IC gerbang logika dalam kemasan IC dan memiliki 10 output yang bekerja atau aktif secara bergantian, untuk mengaktifkan output ini terdapat pin clock yang terhubung dengan output IC NE555.

Selaian IC 4017 terdapat IC NE555 yang juga merupakan komponen penting pada running led ini, dimana fungsinya sebagai penghasil clock atau pulse untuk mengaktifkan output IC 4017, terdapat sebuah potensiometer atau resistor variabel yang berfungsi untuk mengatur waktu tunda (delay) dari output IC NE555, sumber yang digunakan pada project kali ini menggunakan sumber 5V DC.

Berikut ini desain layout PCB yang saya buat menggunakan software EAGLE.

Setelah layout di cetak pada PCB dan di etching kemudian dipasang komponen dan di solder.

Line Follower Robot Using PID Control

Line Follower Robot merupakan robot yang dapat mengikuti garis, sebagai peng-indera robot ini menggunakan sensor yang  berguna untuk membaca atau mendeteksi garis, warna garis yang biasa di gunakan adalah putih untuk base/dasar lapangan warna hitam dan garis hitam untuk base/dasar lapangan putih, dengan dua warna berbeda itu sensor dapat mendeteksi garis dengan cara membedakan warna yang gelap dan warna yang terang.

Untuk sensor yang biasa digunakan untuk membaca garis diantaranya sensor photodioda, phototransistor, infrared maupun sensor LDR (Light Dependent Resistor), untuk robot yang saya buat kali ini menggunakan sensor photodioda kenapa sensor itu, karena sensor ini mudah didapat yang banyak dijual di toko komponen elektronika dan harga yang juga terjangkau tentunya.

Gambar Ilustrasi Mekanisme Pembacaan Sensor Garis.

Kemudian untuk pemeroses atau otak dari robot ini menggunakan mikrokontroler, untuk robot line follower kali ini saya menggunakan mikrokontroler arduino yaitu arduino uno fungsi dari mikro untuk memproses data dari sensor dan kemudian mengontrol motor sebagai aktuator penggerak robot, mikrokontroler ini di isi dengan program atau coding yang akan mengatur robot untuk bernavigasi mengikuti garis.

Lalu bagaimana robot bisa dengan baik bernavigasi mengikuti garis, yaap.. kita masuk pada inti dari robot ini yaitu sistem kontrol PID pada robot line follower, dengan menerapkan kontroler PID yang tepat pada robot line follower pergerakan robot akan lebih halus dibandingkan menggunakan kontrol ON-OFF.

Apa itu PID?

PID singkatan dari Proporsional Integral Derivative, merupakan sebuah algoritma kontrol yang sudah lama ada dan sangat populer digunakan pada sistem kontrol di industri maupun dibidang robotic, sistem kendali ini dapat digunakan pada sistem yang memiliki umpan balik (feedback), kontrol PID ini akan menghitung nilai error, yaitu perbedaan antara nilai setpoint (nilai yang diinginkan) dan variabel prosses terukur (process variable), kontrol ini akan mencoba untuk megurangi nilai error agar menuju ke setpoint yang diinginkan.

Diagram Blok Kontrol PID

Bentuk Kontroler PID Diskrit

Diagram Blok Penerapan Kontrol PID Pada Robot Line Follower

• Setpoint, merupakan parameter nilai yang diinginkan.
• Process Variable, merupakan bobot nilai sensor yang dibaca sesuai dengan pembacaan sensor saat itu.
• Error, merupakan nilai kesalahan yang di dapat dari ( Setpoint - Process Variable ).

Kontrol PID Pada Robot Line Follower

Robot line follower yang akan di kontrol degan PID kali ini menggunakan 8 sensor, garis yang digunakan dengan lebar 2-3 cm yang memungkinkan mengenai 2 sensor kemudian lakukan mapping pada sensor untuk mendapatkan nilai process variable, untuk 8 sensor hasil mapping nilai process variable kurang lebih sebagai berikut :

    /** 1 di asusmsikan sensor mengenai garis **/
    case 0b00000001 : NilaiPosisi = -10; break;
    case 0b00000111 : NilaiPosisi = -9; break;
    case 0b00000011 : NilaiPosisi = -8; break;
    case 0b00000010 : NilaiPosisi = -7; break;
    case 0b00001110 : NilaiPosisi = -6; break;
    case 0b00000110 : NilaiPosisi = -5; break;
    case 0b00000100 : NilaiPosisi = -4; break;
    case 0b00011100 : NilaiPosisi = -3; break;
    case 0b00001100 : NilaiPosisi = -2; break;
    case 0b00001000 : NilaiPosisi = -1; break;
    case 0b00011000 : NilaiPosisi = -0; break;
    case 0b00010000 : NilaiPosisi =  1; break;
    case 0b00110000 : NilaiPosisi =  2; break;
    case 0b00111000 : NilaiPosisi =  3; break;
    case 0b00100000 : NilaiPosisi =  4; break;
    case 0b01100000 : NilaiPosisi =  5; break;
    case 0b01110000 : NilaiPosisi =  6; break;
    case 0b01000000 : NilaiPosisi =  7; break;
    case 0b11000000 : NilaiPosisi =  8; break;
    case 0b11100000 : NilaiPosisi =  9; break;
    case 0b10000000 : NilaiPosisi =  10; break;

kondisi ideal robot adalah pada saat sensor berada pada posisi 00011000 (nilai 1 di asumsikan sensor mengenai garis) atau NilaiPosisi = 0 dan Setpoint = 0 merupakan posisi ideal robot line follower jika NilaiPosisi tidak = 0 berarti robot tidak pada posisi ideal dan artinya ada nilai error, pada kondisi error output PID akan mengeluarkan hasil kendalinya sesuai dengan besaran error yang terjadi dan kemudian akan dikalkulasikan dengan nilai base PWM yang ditentukan untuk menjadi PWM ke motor kiri dan kanan.

Formula perhitungan PWM motor kiri dan kanan sebagai berikut :
motorKi = BasePWM - outPID;      ( Motor Kiri )
motorKa = BasePWM + outPID;    ( Motor Kanan )

Pada pemrograman robot line follower perhitungan PID ditulis sebagai berikut :

double Error = 0, SumError = 0, LastError = 0;
double BasePWM = 250; 
double Kp = 43;       // Proporsional 
double Ki = 0.2;      // Integral     
double Kd = 145;      // Diferensial
double Ts = 1;        // Time sampling

/**** Fungsi perhitungan PID ****/
void lineFollow() {
  robotPosition();
  int SetPoint = 0;                      // Setpoint yang diinginkan
  Error = SetPoint - NilaiPosisi;        // Error
  double DeltaError = Error - LastError; // Delta Error (Selisih error sekarang e(t) dengan error sebelumya e(t-1))
  SumError += LastError;                 // Akumulasi error
  double P = Kp * Error;                 // Kontrol proporsional
  double I = Ki * SumError * Ts;         // Kontrol integral
  double D = ((Kd / Ts) * DeltaError);   // Kontrol derivative
  LastError = Error;                     // Error sebelumnya
  outPID = P + I + D;                    // Output PID
  double motorKi = BasePWM - outPID;     // Motor Kiri
  double motorKa = BasePWM + outPID;     // Motor Kanan
  /*** Pembatasan kecepatan ***/
  if (motorKi > Kec_Max)motorKi = Kec_Max;
  if (motorKi < Kec_Min)motorKi = Kec_Min;
  if (motorKa > Kec_Max)motorKa = Kec_Max;
  if (motorKa < Kec_Min)motorKa = Kec_Min;
  driveMotor(motorKi, motorKa);
}

Tuning Kontroler PID Robot Line Follower
Proses tuning bertujuan untuk menentukan nilai yang tepat untuk parameter aksi kontrol proporsional, integral, derivative pada robot line follower, proses tuning dilakukan dengan menggunkan metode tuning Ziegler-Nichols metode ini dilakukan dengan cara memberikan kontrol proporsional pada sistem close loop dan plant di dalamnya.

Kemudian memberikan nilai Kcr (kontrol proporsional), nilai Ki = 0 (kontrol integral) dan Kd = 0 (kontrol derivative) hingga sistem memperlihatkan grafik yang berosilasi terus menerus secara teratur contoh pada gambar berikut :

Dari grafik osilasi yang berkesinambungan dan dari penguatan Kcr kemudian dapatkan nilai Pcr (periode kritis) untuk mendapatkan nilai Kp, Ki, Kd dihitung sesuai aturan Ziegler-Nichols sebagai berikut:

Setelah nilai Kp, Ki, Kd di dapatkan kemudian masukkan pada program line follower, jika semua nilai parameter sudah tepat maka robot akan bergerak mengikuti garis dengan baik dan akan didapatkan grafik yang memperlihatkan respon posisi yang selalu menuju setpoint seperti gambar berikut :

Untuk hasilnya silahkan lihat pada video berikut.

Referensi : 

• https://id.wikipedia.org/wiki/PID