---
title: Line Follower Robot dengan PID Control

---

# Laporan Proyek Sistem Kendali PID pada Line Follower Robot

Mata Kuliah: Sistem Kendali dan Mekanika
Dosen: Hasbi Ash Shiddieqy, S.T., M.T.
Nama Kelompok: Kelompok 3
Tanggal: 10 Januari 2025

## Nama Kelompok
* Muhammad Naufal Atha Al-Khairi / 1103223059
* Muhammad Hafidz Darul Quro / 1103223052
* Muhammad Abdiel Abrar / 1103223218
* Raihan Nur Ramadhan Sundana / 1103223177

## Daftar Isi

> [TOC]

> **[CLO 3]** Mampu menentukan dan menerapkan penggunaan kendali proporsional, integral, datau derivatif pada motor listrik untuk mencapai kestabilan.
<!--
Indikator ketercapaian
"1. Ketepatan dalam menyusun rancangan sistem kendali sederhana menggunakan pengendali PID untuk mencapai kestabilan.
2. Ketepatan dalam menyusun rancangan sistem kendali menggunakan motor listrik, khususnya motor DC."
>
-->

## 1. Pendahuluan
Robot Line Follower adalah robot otomatis yang dirancang untuk bergerak mengikuti jalur tertentu, biasanya berupa garis yang terdeteksi oleh sensor. Robot ini merupakan contoh sederhana dari penerapan sistem tertanam dan robotika, yang menggabungkan desain mekanis, komponen elektronik, dan pemrograman.

Robot ini tidak hanya berkembang sebagai proyek edukasi untuk mempelajari dasar-dasar robotika, tetapi juga menjadi alat yang bermanfaat dalam berbagai aplikasi industri, seperti pergudangan dan logistik, berkat kemampuannya untuk beroperasi secara otomatis mengikuti jalur yang telah ditentukan.

### 1.1 Tujuan
1. Mengembangkan mobil yang mampu bergerak mengikuti garis secara otomatis.
2. Memahami dan mengimplementasikan algoritma PID secara efektif untuk pengendalian robot.
3. Memastikan sensor dapat mendeteksi dan membaca garis dengan akurat.
4. Mengatur RPM motor pada setiap sisi agar dapat menyesuaikan kecepatan dengan perubahan jalur.

## 2. Desain Sistem
### 2.1 Rancangan Sistem Kendali Loop Tertutup PID
PID adalah singkatan dari Proportional, Integral, dan Derivative, yang merupakan jenis kontrol feedback pada sistem kontrol. PID digunakan untuk mengatur sistem agar dapat mencapai nilai yang diinginkan dengan cara mengukur dan mengoreksi perbedaan antara nilai target (setpoint) dengan nilai aktual. Salah satu aplikasi umum PID adalah pada sistem robotik, seperti robot line follower, untuk memastikan gerakannya tetap presisi dan stabil saat mengikuti garis pandu.

Pada robot line follower yang kami buat, nilai P, I, dan D masing-masing memiliki pengaruh signifikan pada respon sistem. Nilai-nilai ini bekerja secara bersamaan untuk memberikan kontrol yang optimal dalam mengatur kecepatan dan arah motor. Berikut adalah penjelasan pengaruh setiap nilai dalam robot ini:

* Fungsi Nilai P (Proportional)
Nilai P menentukan besar koreksi yang diberikan berdasarkan jarak robot dari set point. Jika posisi robot jauh dari garis, nilai P akan menghasilkan koreksi yang besar untuk mengembalikan robot ke lintasan. Dengan kata lain, nilai P memastikan robot dapat segera kembali ke jalur saat terjadi penyimpangan. Namun, nilai P yang terlalu tinggi dapat membuat robot bergerak terlalu cepat dan tidak stabil.
* Fungsi Nilai I (Integral)
Nilai I berfungsi untuk memperbaiki kesalahan kecil yang terjadi secara terus-menerus dan tidak dapat sepenuhnya diatasi oleh nilai P. Jika robot cenderung menyimpang sedikit dari garis meskipun telah diperbaiki oleh nilai P, nilai I akan bekerja untuk mengatasi penyimpangan tersebut. Nilai I membantu menjaga posisi robot tetap konsisten di tengah garis hitam.
* Fungsi Nilai D (Derivative)
Nilai D bertugas untuk memperhalus pergerakan robot dengan mengurangi kecepatan koreksi yang terlalu cepat atau agresif. Nilai ini bekerja berdasarkan perubahan error, sehingga robot dapat bergerak lebih stabil tanpa osilasi berlebihan, terutama saat melewati tikungan tajam atau perubahan arah pada lintasan.


>Deskripsi:
Input: Setpoint (kecepatan/posisi yang diinginkan)
Pengendali PID: Menyesuaikan sinyal kontrol berdasarkan error
Plant: Motor DC
Output: Kecepatan atau posisi aktual

Berikut ini merupakan penjelasan dari Diagram Close Loop Diatas:

- **Setpoint**: Posisi robot di tengah garis hitam dengan nilai error 0.
- **Sensor**: Sensor yang digunakan adalah Infrared berfungsi untuk mendeteksi posisi robot relatif terhadap garis hitam
- **Aktuator**: L298N Motor Driver berfungsi untuk untuk mengendalikan gerak motor DC, baik dari arah putaran maupun kecepatan motor DC.
- **Proses variabel**: variabel proses yang digunakan berupa error correction untuk memperbaiki posisi robot line follower.

### 2.2 Persamaan PID dan Metode Tuning
#### Persamaan PID

$$
correction = (kp * error) + (ki * integral) + (kd * derivative);
$$

kp: gain proportional
ki: gain integral
kd: gain derivatif

#### Error
##### Pembacaan Nilai Sensor
Robot menggunakan lima sensor IR yang dipasang secara berjejer untuk mendeteksi posisi garis. Sensor-sensor tersebut menghasilkan nilai analog yang menunjukkan intensitas pantulan cahaya dari permukaan. Berikut adalah kode untuk

int sensorValues[] = {
analogRead(sensorLeftPin),
analogRead(sensorMiddleLeftPin),
analogRead(sensorCenterPin),
analogRead(sensorMiddleRightPin),
analogRead(sensorRightPin)
};

##### Pemberian Bobot pada Sensor

Setiap sensor memiliki bobot yang mewakili posisinya relatif terhadap garis tengah robot. Bobot ini digunakan untuk menghitung seberapa jauh posisi garis dari titik tengah. Bobot diberikan sebagai berikut:

weights[] = {-2, -1, 0, 1, 2};

##### Menghitung Seberapa Jauh Garis dari Posisi Tengah Robot

Untuk menghitung seberapa jauh garis dari posisi tengah robot, setiap nilai sensor dikalikan dengan bobotnya masing-masing, kemudian dijumlahkan untuk mendapatkan sumWeights. Hanya nilai sensor yang melebihi ambang batas (irThreshold) yang dihitung untuk memastikan hanya deteksi garis yang valid yang digunakan:

irThreshold = 500;

int sumWeights = 0;
int sumSensorValues = 0;

for (int i = 0; i < 5; i++) {
if (sensorValues[i] > irThreshold) {
sumWeights += weights[i] * sensorValues[i];
sumSensorValues += sensorValues[i];
}
}

##### Perhitungan Error

Error dihitung sebagai perbandingan antara sumWeights dan sumSensorValues. Hal ini memberikan nilai error yang merepresentasikan jarak relatif dan arah garis dari tengah robot. Jika sumSensorValues tidak nol, error dihitung sebagai berikut:

float error = 0;
if (sumSensorValues != 0) {
error = (float)sumWeights / sumSensorValues;
}

#### Integral

Fungsi integral adalah untuk mengakumulasi error yang berguna untuk mengurangi Steady-State Error

integral += error;

Namun, jika tanpa batasan, integral dapat menjadi sangat besar jika error terus berakumulasi yang menyebabkan kontrol tidak stabil. Integral Windup. Solusi nya adalah menambahkan pembatasan integral sebagai berikut:

integral = constrain(integral, -100, 100);

#### Derivatif
Derivatif berguna untuk menghitung selisih antara error saat ini dan error sebelumnya, dan akan di perbaharui dari waktu ke waktu

derivative = error - lastError;
// Kode lainnya
lastError = error;

#### Tuning Parameter PID

Metode tuning yang akan digunakan adalah Ziegler Nichols. Metode tuning ini bekerja dengan meningkatkan nilai Kp secara bertahap sampai ke Kp kritis (Kc). Kc adalah kondisi dimana mobil berosilasi secara stabil. Jarak antar gelombang adalah konstan, dan direpresentasikan dengan T. Setelah menemukan nilai Kp, Kc, dan T yang tepat, ketiga nilai tersebut dapat diimplementasikan kedalam tabel Ziegler Nichols sebagai berikut :

| Metode | Kp | Ki | Kd |
| -------- | -------- | -------- | -------- |
| P | 0.5 Kc | - | - |
| PI | 0.45 Kc | 1.2 Kp/T | - |
| PID | 0.6 Kc | 2 Kp/T | Kp T/8 |

### 2.3 Mekanik Motor DC

Teori Fungsi Transfer Motor DC

Fungsi transfer motor DC digunakan untuk memodelkan hubungan antara input (tegangan yang diberikan ke motor) dan output (kecepatan atau torsi motor) dalam domain waktu atau frekuensi. Fungsi transfer ini mempermudah analisis dan desain sistem kendali, seperti PID, pada robot line follower ini.

$$
ω(s)/Va(s)
$$

Rumus ini memodelkan hubungan antara **input** $(Va)$ dan **output** $(ω)$ motor DC, yang digunakan untuk analisis dan desain kendali seperti PID.

Mekanisme yang dipakai :
#### Sensor IR
Mendeteksi perbedaan warna, hitam dan putih, pada jalur lintasan. Ketika mendeteksi warna hitam, sensor akan mengirimkan sinyal berupa nilai sensor dengan nilai lebih dari 500, dan ketika mendeteksi warna putih, sensor akan mengirimkan nilai kurang dari 500. Sinyal ini kemudian dikirimkan ke **Arduino** untuk diproses lebih lanjut.
#### Arduino Uno R3
Sebagai pusat pengendali robot, Arduino memproses input dari sensor, menghitung kontrol PID, dan mengirimkan instruksi ke driver motor untuk mengatur kecepatan gerakan berdasarkan perhitungan PID. Instruksi yang akan dikeluarkan oleh Arduino adalah sebagai berikut

baseSpeed = 200;

int adjustedSpeedLeft = baseSpeed + correction
int adjustedSpeedRight = baseSpeed - correction

// Ensure speeds are within valid range
adjustedSpeedLeft = constrain(adjustedSpeedLeft, 0, 255);
adjustedSpeedRight = constrain(adjustedSpeedRight, 0, 255);

if (error > 0) {
// Turning right
moveMotors(LOW, HIGH, LOW, HIGH, adjustedSpeedLeft, adjustedSpeedRight);
} else if (error < 0) {
// Turning left
moveMotors(LOW, HIGH, LOW, HIGH, adjustedSpeedLeft, adjustedSpeedRight);
} else {
// Moving straight
moveMotors(LOW, HIGH, LOW, HIGH, baseSpeed, baseSpeed);
}

Motor memiliki kecepatan awal 200 RPM, dan akan berubah sesuai dengan *correction*, apapbila error positif yang mana terdeteksi oleh sensor kanan, maka kecepatan motor kanan akan berkurang, sedangkan kecepatan motor kiri akan bertambah, berlaku untuk sebaliknya. Untuk kondisi error sama dengan 0, maka motor kiri dan kanan akan bergerak maju dengan kecepatan yang sama.

#### Driver Motor L298N
Bertindak sebagai penghubung antara Arduino dan motor DC, memungkinkan pengendalian kecepatan dan putaran motor dengan memanfaatkan sinyal PWM yang dikirimkan oleh Arduino.
#### Motor DC
Motor ini digunakan untuk menggerakkan roda robot. Kecepatan motor diatur menggunakan sinyal dari driver motor L298N.

## 3. Pengujian Sistem
Tuning parameter PID (P, I, D) menggunakan metode Ziegler-Nichols.

### 3.1 Analisis Transient Respon (PID)
#### Panduan Plot

  Serial.print("Error: ");
  Serial.print(error);
  Serial.print("\tCorrection: ");
  Serial.print(correction);
  Serial.print("\tLeft: ");
  Serial.print(adjustedSpeedLeft);
  Serial.print("\tRight: ");
  Serial.println(adjustedSpeedRight);

#### Pengukuran PID

##### Percobaan ke-1 (sebelum tuning) :

Kp = 5000, Ki = 0, dan Kd = 0

---

---

Pada grafik percobaan pertama, dengan Kp 5000, sistem sangat sensitif terhadap error dan tidak memiliki mekanisme untuk memperbaiki osilasi. Error paling besar terjadi karena Kp terlalu besar sehingga menyebabkan overshoot yang tinggi dan juga karena tidak adanya nilai Ki dan Kd. Nilai steady state error cukup besar karena tanpa Ki sistem tidak mampu menghilangkan eror steady state. Sistem menunjukkan kecenderungan berosilasi karena nilai Kp yang besar menyebabkan respons berlebihan terhadap eror.

##### Percobaan Ke-2 (setelah tuning) :

Kp = 3000, Ki = 1500, dan Kd = 625

---


---

Pada grafik percobaan kedua, dengan Kp 3000, Ki 1500, dan Kd 625, walau menggunakan Kp yang tinggi menyebabkan sistem merespons eror dengan cepat, nilai Ki membantu memperbaiki eror secara bertahap dan Kd memberikan pengurangan osilasi yang terjadi, grafik menunjukkan sistem mencapai kestabilan dengan respons yang lebih halus dibandingkan sebelum tuning. Nilai steady state error juga menjadi lebih kecil dibandingkan sebelum tuning dan penambahan Ki dan Kd pada tuning saat ini, karena Ki dan Kd membantu mengurangi error secara bertahap tidak seperti pada grafik sebelumnya. Grafik menunjukkan osilasi yang lebih minimal dari percobaan sebelumnya yang menandakan PID berhasil menjaga kestabilan sistem.

#### Transcient Response Percobaan Pertama dan Kedua

| Setpoint (error) |Kp|Ki|Kd| Delay time (Td) | Rise time (Tr) | Peak time (Tp) | Settling time (Ts) |
| ---------------- | --------------- | -------------- | -------------- | ------------------| -------------- | -------------- | ------------------|
|0|5000|0|0|0.2|0.3|2.8|3
|0|3000|1500|625|0.2|0.25|2.5|2.75

### 3.2 Analisis Mekanik Gear
Analisis Mekanik Gear Motor DC terhadap transfer daya :

| Duty Cycle (%) | Nilai Output (Voltage)| Output Terukur (Voltage) | Max Arus Motor(A) | Speed (rpm) |
| ----- | ----- | ------ | ----- | ---- |
|37%|2.74|2.69|1.35|74|
|84%|6.22|6.15|3.11|168|

---
Grafik Kecepatan vs Waktu terhadap Perubahan Duty Cycle dalam Lintasan Lurus

---

### 3.3 Analisis Hasil

Sistem setelah tuning menggunakan metode Ziegler-Nichols, yang sebelumnya osilasi, menuju setpoint "0".
Steady-State error berkurang secara signifikan setelah tuning yang menunjukkan sistem dapat mempertahankan kestabilan pada setpoint.
Rise time menjadi lebih cepat dengan overshoot yang terkontrol yang menunjukkan peningkatan respons sistem terhadap lonjakan yang berlebihan.

## 4. Evaluasi kinerja sistem

Apakah parameter PID yang dirancang telah optimal?

hampir optimal, hal ini dapat dipengaruhi oleh banyaknya jumlah percobaan, karena percobaan dapat meningkatkan akurasi pada saat metode tuning Ziegler-Nichols

Apakah sistem dapat mempertahankan performa optimal dalam jangka waktu lama?

Ya, karena setelah osilasi diperbaiki oleh PID membuat sistem stabil dan optimal dalam jangka waktu yang lama

Berdasarkan hasil pengujian, parameter PID yang dirancang menunjukkan performa hampir optimal, dalam mengendalikan motor DC. Hal ini ditunjukkan oleh:

1. Nilai steady-state error yang kecil
2. Respon waktu rise time yang cepat
3. Overshoot yang sedikit sehingga menyebabkan sistem hampir stabil

## 5 Hasil dan Saran
### 5.1 Kesimpulan

Dalam implementasi Line Follower Robot sebagai proyek untuk Sistem Kendali Mekanika menggunakan Kendali PID, berhasil diimplementasikan untuk mencapai hampir kestabilan kecepatan/posisi motor DC.

Hal ini bisa dipengaruhi dengan penyesuaian nilai PID saat pengujian yang hampir mencapai kestabilan sistem, juga jumlah percobaan PID maupun saat mencari nilai Kp,Ki,Kd menggunakan metode Ziegler-Nichols.

### 5.2 Rekomendasi

Menggunakan modul *bluetooth* agar memudahkan dalam *tuning* PID. Implementasi lebih lanjut dalam penggunaan robot dengan dua roda, sehingga mengurangi massa total robot dan mempermudah robot dalam berputar atau navigasi sirkuit yang lebih tajam sudutnya. Penggunaan sensor QTR (Quadrative Reflective Sensor) atau sensor TCRT5000 membantu dalam penerapan PID dalam proyek karena hasil deteksi yang diberikan lebih baik. Penggunaan daya yang baik dan suplai daya yang baik juga diperlukan dalam pengujian alat ini, karena troubleshooting wyang cukup banyak dilakukan menghabiskan daya baterai cukup cepat karena dalam proyek kali ini menggunakan 4 dinamo sebagai motor penggerak.

## Dokumentasi Proyek

Foto Implementasi:

Kode :

// Right motor
int enableLeftMotor = 5;
int leftMotorPin1 = 7;
int leftMotorPin2 = 8;

// Left motor
int enableRightMotor = 6;
int rightMotorPin1 = 9;
int rightMotorPin2 = 10;

// IR Sensors
int sensorLeftPin = A0;
int sensorMiddleLeftPin = A1;
int sensorCenterPin = A2;
int sensorMiddleRightPin = A3;
int sensorRightPin = A4;

// Threshold sensor IR
int irThreshold = 500;

// PID constants
float kp = 3;
float ki = 4;
float kd = 0.5625;

// PID variables
float lastError = 0;
float integral = 0;

// Define light turn threshold
float lightTurnThreshold = 0.5; // Adjust this threshold as needed

float deadZone = 0.1;

// Base speed for motors
int baseSpeed = 200;

void setup() {
  // Initialize motor pins
  pinMode(enableRightMotor, OUTPUT);
  pinMode(leftMotorPin1, OUTPUT);
  pinMode(leftMotorPin2, OUTPUT);

  pinMode(enableLeftMotor, OUTPUT);
  pinMode(rightMotorPin1, OUTPUT);
  pinMode(rightMotorPin2, OUTPUT);

  // Initialize sensor pins
  pinMode(sensorLeftPin, INPUT);
  pinMode(sensorMiddleLeftPin, INPUT);
  pinMode(sensorCenterPin, INPUT);
  pinMode(sensorMiddleRightPin, INPUT);
  pinMode(sensorRightPin, INPUT);

  // Start Serial Monitor for debugging
  Serial.begin(9600);
}

void loop() {
  // Read sensor values
  int sensorValues[] = {
    analogRead(sensorLeftPin),
    analogRead(sensorMiddleLeftPin),
    analogRead(sensorCenterPin),
    analogRead(sensorMiddleRightPin),
    analogRead(sensorRightPin)
  };

  // Calculate weighted error
  int weights[] = {-2, -1, 0, 1, 2};
  int sumWeights = 0;
  int sumSensorValues = 0;

  for (int i = 0; i < 5; i++) {
    if (sensorValues[i] > irThreshold) {
      sumWeights += weights[i] * sensorValues[i];
      sumSensorValues += sensorValues[i];
    }
  }

  float error = 0;
  if (sumSensorValues != 0) {
    error = (float)sumWeights / sumSensorValues;
  }

  if (fabs(error) < deadZone) {
    error = 0;
  }

  // Calculate PID terms
  float derivative = error - lastError;
  integral += error;  // Tambahkan ini untuk mengakumulasi error
  
  // Opsional: tambahkan anti-windup untuk membatasi integral
  integral = constrain(integral, -100, 100);  // Batasi nilai integral agar tidak terlalu besar
      
  float correction = (kp * error) + (ki * integral) + (kd * derivative);

  // Adjust motor speeds based on error
  int adjustedSpeedLeft = baseSpeed + (correction * fabs(error));
  int adjustedSpeedRight = baseSpeed - (correction * fabs(error));

  // Ensure speeds are within valid range
  adjustedSpeedLeft = constrain(adjustedSpeedLeft, 0, 255);
  adjustedSpeedRight = constrain(adjustedSpeedRight, 0, 255); 

  // Apply interpolation for smoother turns
  if (error > 0) {
    // Turning right
    moveMotors(LOW, HIGH, LOW, HIGH, adjustedSpeedLeft, adjustedSpeedRight);
  } else if (error < 0) {
    // Turning left
    moveMotors(LOW, HIGH, LOW, HIGH, adjustedSpeedLeft, adjustedSpeedRight);
  } else {
    // Moving straight
    moveMotors(LOW, HIGH, LOW, HIGH, baseSpeed, baseSpeed);
  }

  lastError = error;

  if (millis() % 500 == 0) {
    Serial.print("Error: ");
    Serial.print(error);
    Serial.print("\tCorrection: ");
    Serial.println(correction);
  }

  Serial.print("Error: ");
  Serial.println(error);
  Serial.println("\tCorrection: ");
  Serial.println(correction);
  Serial.println("\tLeft: ");
  Serial.println(adjustedSpeedLeft);
  Serial.println("\tRight: ");
  Serial.println(adjustedSpeedRight);

  delay(100);
}

// Function to control motor movement with speed parameters
void moveMotors(int leftMotorBackward, int leftMotorForward, int rightMotorBackward, int rightMotorForward, int speedLeft, int speedRight) {
  // Control right motor
  digitalWrite(leftMotorPin1, leftMotorForward);
  digitalWrite(leftMotorPin2, leftMotorBackward);

  // Control left motor
  digitalWrite(rightMotorPin1, rightMotorForward);
  digitalWrite(rightMotorPin2, rightMotorBackward);

  // Set motor speed
  analogWrite(enableRightMotor, speedRight);
  analogWrite(enableLeftMotor, speedLeft);
}

Video Demonstrasi:
[https://www.youtube.com/shorts/V20cfIe5Vow]

## Referensi
https://www.youtube.com/watch?v=SSPc8BPdjuQ

https://projecthub.arduino.cc/anova9347/line-follower-robot-with-pid-controller-01813f

## **Rubrik Penilaian Proyek Kendali PID CLO3**
CLO3 Mampu menentukan dan menerapkan penggunaan kendali proporsional, integral, datau derivatif pada motor listrik untuk mencapai kestabilan.

| **Aspek Penilaian** | **Indikator Kinerja** | **Level 4 (Sangat Baik)** | **Level 3 (Baik)** | **Level 2 (Cukup)** | **Level 1 (Kurang)** | **Skor Maksimum** |
|------------------------------------|---------------------------------------------------------------------------------|----------------------------------|-----------------------------|-----------------------------|----------------------------|-------------------|
| **1. Desain dan Implementasi Sistem (1,2)** | Ketepatan merancang parameter PID, pemodelan sistem, dan implementasi perangkat keras/lunak | Desain parameter sangat tepat, implementasi lengkap dan sistem berjalan optimal. | Desain parameter cukup tepat, implementasi hampir lengkap, sistem berjalan baik. | Desain kurang akurat, implementasi tidak lengkap, sistem berjalan kurang optimal. | Desain tidak tepat, implementasi buruk, sistem tidak berfungsi. | **30** |
| **2. Pengujian Sistem (3)** | Kualitas pengujian performa sistem (respon terhadap setpoint, gangguan, dan perubahan beban) | Pengujian menyeluruh, sistem stabil, respon cepat dan overshoot minimal. | Pengujian cukup baik, sistem stabil dengan respon wajar. | Pengujian terbatas, sistem kurang stabil, respon lambat. | Pengujian buruk, sistem tidak stabil dan respon tidak memadai. | **30** |
| **3. Analisis dan Evaluasi Kinerja Sistem (4,5)** | Kelengkapan analisis hasil pengujian serta evaluasi performa sistem (error, kestabilan, perbaikan tuning) | Analisis mendalam, error minimal, rekomendasi perbaikan jelas dan akurat. | Analisis memadai, error kecil, rekomendasi cukup baik. | Analisis kurang mendalam, error signifikan, rekomendasi terbatas. | Analisis tidak jelas, error besar, tidak ada rekomendasi perbaikan. | **30** |
| **4. Presentasi dan Dokumentasi Proyek** | Kualitas dokumentasi laporan dan kemampuan menyampaikan serta memahami proyek | Laporan lengkap, penyajian sangat jelas, pemahaman mendalam. | Laporan cukup lengkap, penyajian jelas, pemahaman baik. | Laporan kurang lengkap, penyajian tidak jelas, pemahaman terbatas. | Laporan tidak lengkap, penyajian buruk, pemahaman lemah. | **10** |

---

## **Skor Akhir dan Kriteria Penilaian**

| **Rentang Skor** | **Deskripsi Tingkat Pencapaian** |
|------------------|----------------------------------------------------------|
| **85 - 100** | **Sangat Baik:** Proyek memenuhi semua luaran dengan performa optimal dan analisis mendalam. |
| **70 - 84** | **Baik:** Proyek mencapai sebagian besar luaran dengan performa baik dan analisis memadai. |
| **55 - 69** | **Cukup:** Proyek hanya mencapai luaran dasar, performa dan analisis memerlukan peningkatan. |
| **< 55** | **Kurang:** Proyek tidak mencapai luaran yang diharapkan, memerlukan perbaikan signifikan. |

---