m4

 

Mikro 2024 Modul 4



MODUL IV

KONTROL TANAMAN PADA GREENHOUSE 

(LIDAH BUAYA DAN HIDROPONIK)


1. Pendahuluan [KEMBALI]

        

    Memiliki hewan peliharaan seperti kucing dapat membawa kebahagiaan dan persahabatan bagi pemiliknya. Namun, kesibukan sehari-hari terkadang membuat pemilik kesulitan untuk memberikan perhatian penuh kepada hewan peliharaan mereka, terutama dalam hal pemberian makan dan minum. Hal ini dapat menyebabkan masalah kesehatan bagi hewan peliharaan, seperti malnutrisi, dehidrasi, dan obesitas, jika tidak ditangani dengan baik.

     Untuk mengatasi masalah ini, project "Smart Pet Feeder" hadir sebagai solusi inovatif untuk membantu pemilik kucing dalam merawat hewan peliharaan mereka dengan lebih baik. Project ini memanfaatkan teknologi Arduino, dan berbagai macam sensor, untuk mengontrol food dispenser dan water dispenser secara otomatis, memastikan kucing mendapatkan makanan dan air yang cukup sesuai dengan kebutuhannya.

    2. Tujuan [KEMBALI]

    ·       Memastikan Jadwal Makan dan Minum yang Tepat: Smart Pet Feeder dapat diprogram untuk mengeluarkan makanan dan air pada waktu yang telah ditentukan, sesuai dengan kebutuhan kucing dan pola makannya. Hal ini membantu menjaga kesehatan dan berat badan ideal kucing, serta mencegah overfeeding dan dehidrasi.

    ·       Pemantauan Status Makanan dan Air: Projek ini dapat dilengkapi dengan sensor untuk memantau status makanan dan air pada dispenser. Sensor ini akan memberikan informasi kepada pemilik tentang ketersediaan makanan dan air, sehingga mereka dapat dengan mudah mengetahui kapan refill diperlukan.

    ·       Kemudahan Pengoperasian: Smart Pet Feeder dirancang dengan mudah digunakan dan diprogram. Pemilik dapat mengatur jadwal makan dan minum, serta memantau status makanan dan air.

    Peningkatan Kualitas Hidup Hewan Peliharaan: Dengan memastikan akses yang konsisten terhadap makanan dan air yang segar, Smart Pet Feeder membantu meningkatkan kualitas hidup kucing dan memberikan ketenangan bagi pemiliknya saat mereka tidak berada di rumah

    3. Alat dan Bahan [KEMBALI]

      

    3.1. Alat:

    a)     Jumper



     

    b)     Breadboard

     



    c)     Adapter 5V 2A



     

    3.2. Komponen:

    a)     Sensor Touch



     

     

    b)     Sensor Loadcell


     

     

    c)     Sensor Ultrasonic


    d)     Sensor Water Level


     

    e)     Sensor Turbidity


    f)      LCD I2C


     

     

    g)     Motor Servo


    h)     L239D


    i)      Motor DC


    j)      RTC DS3231


    k)     LED Super Bright


     

     

     

     

    l)      Arduino UNO


     












    4. DASAR TEORI [KEMBALI]


    a)     Sensor Touch

    Sensor touch merupakan komponen elektronik yang mendeteksi sentuhan atau kontak fisik. Sensor ini bekerja dengan berbagai prinsip, seperti:

    ·       Resistif: Sensor ini memiliki dua lapisan konduktif yang dipisahkan oleh udara. Saat disentuh, resistensi antara kedua lapisan akan berubah, sehingga dapat dideteksi oleh mikrokontroler.

    ·       Kapasitif: Sensor ini menggunakan kapasitansi antara permukaan sensor dan jari manusia. Saat disentuh, kapasitansi akan berubah, sehingga dapat dideteksi oleh mikrokontroler.

    ·       Inframerah: Sensor ini menggunakan sinar inframerah untuk mendeteksi keberadaan objek. Saat objek menyentuh sensor, sinar inframerah akan terhalang, sehingga dapat dideteksi oleh mikrokontroler.

     


    Gambar grafik respon touch sensor

     

     

     

    b)     Sensor Loadcell

    Sensor loadcell merupakan komponen elektronik yang mengukur berat atau gaya. Sensor ini bekerja dengan cara mengubah tekanan mekanis menjadi sinyal listrik. Sinyal listrik ini kemudian diproses oleh mikrokontroler untuk menentukan berat atau gaya yang diukur.


    Gambar grafik respon sensor loadcell

     

    c)     Sensor Ultrasonic

    Sensor ultrasonic merupakan komponen elektronik yang mendeteksi jarak atau keberadaan objek menggunakan gelombang ultrasonik. Sensor ini memancarkan gelombang ultrasonik dan mengukur waktu yang dibutuhkan gelombang untuk kembali setelah dipantulkan oleh objek. Jarak objek dapat dihitung berdasarkan waktu tersebut.

     


    Gambar grafik respon sensor ultrasonic

     

     

    d)     Sensor Water Level

    Sensor water level merupakan komponen elektronik yang mendeteksi ketinggian air. Sensor ini bekerja dengan berbagai prinsip, seperti:

    ·       Pelampung: Sensor ini menggunakan pelampung yang akan naik atau turun sesuai dengan ketinggian air. Posisi pelampung kemudian dideteksi oleh mikrokontroler.

    ·       Tekanan: Sensor ini menggunakan sensor tekanan untuk mengukur tekanan air. Tekanan air kemudian dikonversi menjadi ketinggian air oleh mikrokontroler.

    ·       Konduktivitas: Sensor ini menggunakan elektroda untuk mendeteksi konduktivitas air. Ketinggian air kemudian dihitung berdasarkan konduktivitas air.


    Gambar grafik respon sensor waterlevel

    e)     Sensor Turbidity

    Sensor turbidity merupakan komponen elektronik yang mengukur kekeruhan air. Sensor ini bekerja dengan cara memancarkan cahaya dan mengukur intensitas cahaya yang diteruskan atau dipantulkan oleh air. Kekeruhan air kemudian dihitung berdasarkan intensitas cahaya tersebut.


    Gambar grafik respon turbidity sensor

     

    f)      LCD I2C

    LCD I2C merupakan layar LCD yang dapat dihubungkan ke mikrokontroler menggunakan protokol I2C. Protokol I2C memungkinkan komunikasi antara mikrokontroler dan LCD dengan hanya menggunakan dua kabel data.


    g)     Motor Servo

    Motor servo merupakan motor DC yang dapat dikontrol posisinya dengan presisi tinggi. Motor servo memiliki tiga kabel, yaitu kabel power, kabel ground, dan kabel sinyal. Posisi motor servo dapat dikontrol dengan mengirimkan sinyal PWM (Pulse Width Modulation) ke kabel sinyal.

    h)     L239D

    L239D merupakan driver motor H-bridge yang dapat digunakan untuk mengontrol dua motor DC secara independen. L239D memiliki empat input, yaitu dua input untuk masing-masing motor DC, dan empat input untuk mengaktifkan motor DC.


     

    i)      Motor DC

    Motor DC merupakan motor listrik yang bekerja dengan menggunakan medan magnet dan arus listrik. Motor DC memiliki dua terminal, yaitu terminal positif dan terminal negatif. Arah putaran motor DC dapat dikontrol dengan mengubah  polaritas tegangan yang diterapkan pada terminal.


    Gambar grafik respon motor dc

    j)      RTC DS3231

    RTC DS3231 merupakan real-time clock (RTC) yang dapat digunakan untuk menyimpan waktu dan tanggal. RTC DS3231 memiliki baterai internal yang memungkinkannya untuk terus berjalan bahkan ketika daya utama dimatikan.


    k)     LED Super Bright

    LED Super Bright merupakan LED yang memiliki intensitas cahaya yang lebih tinggi dari LED biasa. LED Super Bright sering digunakan untuk aplikasi yang membutuhkan pencahayaan yang terang, seperti lampu jalan dan lampu indikator.

    l)      Arduino UNO

    Arduino UNO merupakan papan mikrokontroler yang berbasis mikrokontroler Atmega328P. Arduino UNO mudah digunakan dan memiliki banyak komunitas online yang dapat membantu pengguna dalam belajar dan mengembangkan proyek mereka.

    5. Percobaan [Kembali]

        a) Prosedur [Kembali]  

    1. Persiapan Rangkaian:

      • Hubungkan semua komponen sesuai dengan skema rangkaian yang telah dibuat.
      • Unggah kode program Arduino yang telah ditulis ke papan mikrokontroler.
      • Pastikan semua sensor dan aktuator terhubung dengan benar dan berfungsi dengan baik.

    2. Pengujian Pemberian Makan Otomatis:

      • Atur waktu pemberian makan (sarapan, makan siang, dan makan malam) pada RTC.
      • Jalankan program Arduino dan amati kinerja sistem.
      • Pastikan motor servo dispenser makanan aktif pada waktu yang telah diatur.
      • Pantau berat makanan yang dikeluarkan dengan sensor load cell.
      • Pastikan motor servo dispenser makanan mati ketika berat makanan mencapai 100 gram.

    3. Pengujian Pengisian Makanan Manual:

      • Sentuh sensor touch pada dispenser makanan.
      • Amati apakah motor servo dispenser makanan terbuka untuk memungkinkan pengisian manual.
      • Lakukan pengisian makanan secara manual ke dalam dispenser.

    4. Pengujian Indikator Makanan Habis:

      • Kurangi jumlah makanan di dalam dispenser hingga batas minimum.
      • Amati apakah LED merah super terang menyala sebagai indikator makanan hampir habis.

    5. Pengujian Pengisian Air Otomatis:

      • Kosongkan tangki air hingga ketinggian air di bawah 2 cm.
      • Amati apakah motor servo dispenser air aktif untuk melakukan pengisian air.
      • Pantau ketinggian air di tangki dengan sensor level air.
      • Pastikan motor servo dispenser air mati ketika ketinggian air mencapai 5 cm.

    6. Pengujian Pembersihan Tangki Air Otomatis:

      • Tambahkan sedikit kotoran ke dalam tangki air.
      • Amati apakah solenoid valve terbuka untuk mengeluarkan air kotor dari tangki.
      • Pastikan air kotor di dalam tangki terbuang dengan baik.

             - rangkaian simulasi







    • Prinsip Kerja

    1)     Pemberian Makan Otomatis berdasarkan RTC:

    • RTC diprogram untuk waktu-waktu pemberian makan yang diinginkan, yaitu sarapan, makan siang dan makan malam.
    • Ketika waktu pemberian makan tiba berdasarkan RTC:
      • Motor servo untuk mengeluarkan makanan diaktifkan.
      • Load cell sensor akan terus memonitor berat makanan yang dikeluarkan.
      • Jika berat makanan mencapai 100 gram (berat yang diinginkan):
        • Motor servo untuk mengeluarkan makanan dinonaktifkan.

    2)     Pengisian Makanan Manual:

    • Ketika sensor touch disentuh:
      • Motor servo untuk membuka tutup atas dispenser makanan diaktifkan.
      • Ini memungkinkan pengisian makanan secara manual.

    3)     Indikator Makanan Habis:

    • Sensor ultrasonik mengukur jarak antara makanan dan sensor di dalam dispenser.
    • Jika jarak antara makanan dan sensor ultrasonik 10 cm atau lebih (artinya makanan hampir habis):
      • LED red super bright diaktifkan sebagai indikator bahwa dispenser hampir kehabisan makanan.

    4)     Pengisian Air Otomatis:

    • Sensor level air akan terus mengukur tinggi air di tangki air.
    • Jika sensor level air mendeteksi air kurang dari 2 cm di atas permukaan tangki air:
      • Motor servo untuk mengisi air dari dispenser air diaktifkan (asumsi terhubung ke dispenser air terpisah).
      • Pengisian air akan terus berlanjut hingga sensor level air mendeteksi ketinggian air mencapai 5 cm (kapasitas yang diinginkan).

    5)     Pembersihan Tangki Air Otomatis:

    • Sensor kekeruhan akan mendeteksi adanya kotoran di dalam tangki air.
    • Jika sensor kekeruhan mendeteksi adanya kotoran:
      • Solenoid valve diaktifkan untuk membuka dan mengeluarkan air dari tangki air.
      • Ini memungkinkan pembersihan tangki air secara otomatis.

     


    A.    Master


     

     

     

     

    B.    Slave




    • Listing Program 

    A.    Master

    #include <Servo.h>

    #include <RTClib.h>

    #include <HX711.h>

    #include <DTH_Turbidity.h>

    #include <SoftwareSerial.h>

    #include <LiquidCrystal.h>

     

    // Define RTC pins (adjust based on your connections)

    #define SDA A4

    #define SCL A5

     

    // Define sensor pins (adjust based on your connections)

    #define PIN_LOADCELL_DATA 6

    #define PIN_LOADCELL_SCK 7

    #define PIN_SENSOR_TOUCH 3

    #define PIN_TRIGGER_ULTRASONIK 4

    #define PIN_ECHO_ULTRASONIK 5

    #define PIN_SENSOR_WATERLEVEL 2

    #define PIN_SENSOR_TURBIDITY A0

    #define PIN_SOLENOID_VALVE 5

    #define PIN_LED_RED 13

     

    // Define ambang batas (AB)

    const int AB_Loadcell = 100; // gram

    const int AB_AirRendah = 2; // cm

    const int AB_AirTinggi = 5; // cm

    const int AB_Ultrasonik_Refill = 10; // cm (jarak sensor ultrasonik)

    const int AB_Turbidity = 500; // nilai untuk deteksi kekeruhan

     

    // Define communication and variables

    #define BAUD_RATE 9600

    RTC_DS3231 rtc;

    Servo myservo;

    int readLoadcell;

    int readWaterLevel;

    int readTurbidity;

    int readUltrasonic;

     

    long duration;

    int distance;

     

    // Define feeding times (adjust hours and minutes)

    int breakfastHour = 8;

    int breakfastMinute = 0;

    int lunchHour = 12;

    int lunchMinute = 0;

    int dinnerHour = 18;

    int dinnerMinute = 0;

     

    SoftwareSerial mySerial(0, 1); // RX, TX

     

    void setup() {

      Serial.begin(9600);

      mySerial.begin(9600); // Inisialisasi komunikasi serial untuk komunikasi dengan Arduino Penerima

      if (!rtc.begin()) {

        Serial.println("Couldn't find RTC!");

        while (1) {}

      }

      rtc.adjust(DateTime(2024, 6, 15, 0, 0, 0)); // Set initial date and time (replace with current date and time)

     

      pinMode(PIN_LOADCELL_DATA, INPUT);

      pinMode(PIN_LOADCELL_SCK, INPUT);

      pinMode(PIN_SENSOR_TOUCH, INPUT);

      pinMode(PIN_TRIGGER_ULTRASONIK, INPUT);

      pinMode(PIN_ECHO_ULTRASONIK, INPUT);

      pinMode(PIN_SENSOR_WATERLEVEL, INPUT);

      pinMode(PIN_SENSOR_TURBIDITY, INPUT);

    }

     

    void loop() {

      // Check sensor readings

      readLoadcell = analogRead(PIN_LOADCELL_DATA);

      readWaterLevel = analogRead(PIN_SENSOR_WATERLEVEL);

      readTurbidity = analogRead(PIN_SENSOR_TURBIDITY);

      readUltrasonic = analogRead(PIN_TRIGGER_ULTRASONIK);

     

      // Check feeding times and dispense food (communicate with slave)

      DateTime now = rtc.now();

     

      // Check for breakfast time

      if (now.hour() == breakfastHour && now.minute() == breakfastMinute) {

        dispenseFood(); // Call function to dispense food

      }

     

      // Check for lunch time

      if (now.hour() == lunchHour && now.minute() == lunchMinute) {

        dispenseFood();

      }

     

      // Check for dinner time

      if (now.hour() == dinnerHour && now.minute() == dinnerMinute) {

        dispenseFood();

      }

     

      // Check for refill based on touch sensor and water level

      if (digitalRead(PIN_SENSOR_TOUCH) == LOW) {

        refillFood();

      }

     

      // Check for dirty water and drain the tank

      if (readTurbidity > AB_Turbidity) {

        kurasAir();

      }

     

      // Check for dirty water and drain the tank

      if (readUltrasonic >= AB_Ultrasonik_Refill) {

        refillFood();

      }

     

      delay(1000);

    }

     

    void dispenseFood() {

      if (readLoadcell < AB_Loadcell) {

        Serial.write('F'); // Send dispense food command to output arduino

      } else {

        Serial.println("Food container full, stopping dispense.");

      }

    }

     

    void refillFood() {

      digitalWrite(PIN_TRIGGER_ULTRASONIK, LOW);

      delayMicroseconds(2);

      digitalWrite(PIN_TRIGGER_ULTRASONIK, HIGH);

      delayMicroseconds(10);

      digitalWrite(PIN_TRIGGER_ULTRASONIK, LOW);

     

      long duration = pulseIn(PIN_ECHO_ULTRASONIK, HIGH);

      int distance = duration * 0.034 / 2; // cm (adjust conversion factor if needed)

     

      // Send distance value to slave Arduino

      Serial.println(distance);

        if (Serial.available() > 0) {

        distance = Serial.read();  // Read distance value as an integer

        if (distance >= AB_Ultrasonik_Refill) {

          Serial.write('R'); // Send refill food command to output arduino

        }

      }

    }

     

    void refillWater() {

      if (readWaterLevel == AB_AirRendah) {

        Serial.write('W'); // Send refill water command to output arduino

      } else {

        Serial.println("Water container full, stopping refill.");

      }

    }

     

    void kurasAir() {

      Serial.write('K'); // Kirim command kuras air ke arduino output

    }

     

     

     

    B.    Slave

    #include <Wire.h> // Include Wire library for I2C communication

    #include <LiquidCrystal_I2C.h>

    #include <Servo.h>

     

    #define BAUD_RATE 9600

     

    // I2C LCD settings (adjust based on your LCD module)

    #define LCD_I2C_ADDRESS 0x27  // Replace with your LCD's I2C address

    #define LCD_COLUMNS 16

    #define LCD_ROWS 2

    #define PIN_SOLENOID_VALVE 5

    #define PIN_LED_RED 7

     

    // Define servo pin numbers

    #define SERVO1_PIN 4

    #define SERVO2_PIN 5

    #define SERVO3_PIN 6

     

    Servo servo1, servo2, servo3;

     

    // Replace the following lines with the initialization code from your I2C LCD library

    void lcd_init() {

      // I2C initialization and LCD configuration

    }

     

    void lcd_print(const char* message) {

      // Print message to LCD

    }

     

    void lcd_clear() {

      // Clear LCD display

    }

     

    void setup() {

      pinMode(PIN_SOLENOID_VALVE, OUTPUT);

      pinMode(PIN_LED_RED, OUTPUT);

      Serial.begin(BAUD_RATE);

      servo1.attach(SERVO1_PIN);

      servo2.attach(SERVO2_PIN);

      servo3.attach(SERVO3_PIN);

     

      // Call your I2C LCD initialization function

      lcd_init();

     

    }

     

    void loop() {

      char command = Serial.read();

     

      switch (command) {

        case 'F':

          dispenseFood();

          break;

        case 'R':

          refillFood();

          break;

        case 'W':

          refillWater();

          break;

        case 'K':

          kurasAir();

          break;

        default:

          break;

      }

    }

     

    void dispenseFood() {

      Serial.println("Feeding Time!");

      servo2.write(90); // Move dispense food servo (adjust angle as needed)

      delay(5000);       // Wait for food to dispense (adjust time as needed)

      servo2.write(0);    // Move dispense food servo back to closed position

      lcd_print("Dispensing food..."); // Update LCD (adjust message)

      delay(2000);        // Wait for LCD update (adjust time as needed)

      lcd_clear();        // Clear LCD (optional)

    }

     

    void refillFood() {

      lcd_print("Food needs refilling!"); // Update LCD (adjust message)

      delay(2000);                      // Wait for LCD update (adjust time as needed)

      lcd_clear();                      // Clear LCD (optional)

      servo3.write(90);                 // Move refill food servo (adjust angle as needed)

      delay(5000);                       // Wait for food to refill (adjust time as needed)

      servo3.write(0);                    // Move refill food servo back to closed position

    }

     

    void refillWater() {

      servo1.write(90); // Move refill water servo (adjust angle as needed)

      delay(5000);       // Wait for water to refill (adjust time as needed)

      servo1.write(0);    // Move refill water servo back to closed position

      lcd_print("Refilling water...");  // Update LCD (adjust message)

      delay(2000);        // Wait for LCD update (adjust time as needed)

      lcd_clear();        // Clear LCD (optional)

    }

     

    void kurasAir() {

      Serial.write('K'); // Send command to output Arduino (already defined in your code)

     

      // Open solenoid valve for draining

      digitalWrite(PIN_SOLENOID_VALVE, HIGH); // Adjust based on your solenoid logic (HIGH might open)

    }

     

     

    Master



    e. Video Demo [Kembali]