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);
}