M4: Rancang Bangun Smart Robot Wiper Pembersih Panel Surya Berbasis STM32F103C8T6
1. Judul Rancangan [Kembali]
"Rancang Bangun Smart Robot Wiper Pembersih Panel Surya Berbasis STM32F103C8T6"
2. Tujuan Rancangan [Kembali]
1. Merancang dan merealisasikan prototipe sistem pembersih otomatis pada panel surya guna menjaga efisiensi penyerapan intensitas cahaya matahari.
2. Mengimplementasikan mikrokontroler 32-bit (STM32F103C8T6) dalam mengolah data sensor (direct conditional reading) dan mengendalikan aktuator motor stepper secara presisi.
3. Melakukan simulasi dan analisis logika rangkaian secara komprehensif menggunakan perangkat lunak Proteus dan STM32CubeIDE.
4. Mengintegrasikan berbagai komponen perangkat keras (sensor, mikrokontroler, aktuator) dan menganalisis peranannya masing-masing dalam membentuk sistem otomasi yang utuh.
5. Menjalin kemitraan dengan Bapak Zaini, Ph.D. serta memberikan bantuan teknologi terapan kepada masyarakat daerah Batu Busuk untuk memudahkan mereka dalam memanfaatkan dan memelihara instalasi panel surya milik Bapak Zaini, Ph.D.
3. Daftar Alat & Komponen [Kembali]
1. STM32F103C8T6
2. Modul LDR Sensor
3. Ultrasonic Sensor HC-SR04
4. Sensor Arus ACS712-20A
5. Limit Switch
6. Motor Driver l298
7. Motor BiStepper 12V
8. Motor DC 5V
9. LCD 16x2 LM016L
10. Software Pendukung (STM32CubeIDE)
4. Landasan Teori + Grafik Respon Sensor [Kembali]
A. Galodo
Galodo merupakan istilah lokal di Sumatera Barat yang merujuk pada fenomena banjir bandang yang membawa material sedimen berupa lumpur tebal, bebatuan, dan ranting kayu. Daerah Batu Busuk, Kota Padang, yang memiliki topografi berbukit dan dilintasi aliran sungai, sangat rentan terhadap dampak dari cuaca ekstrem dan galodo. Pasca terjadinya hujan lebat atau galodo, hembusan angin dan percikan material sering kali meninggalkan lapisan lumpur kering dan debu tebal pada instalasi luar ruangan. Jika material ini menutupi permukaan panel surya milik warga atau instalasi Bapak Zaini, Ph.D., maka efisiensi penyerapan energi matahari akan anjlok secara drastis. Oleh karena itu, inovasi robot wiper otomatis ini menjadi solusi mitigasi yang sangat mendesak dan relevan untuk kondisi lingkungan di Batu Busuk.
B. Panel Surya dan Pengaruh Kotoran (Soiling Effect)
Panel surya merupakan perangkat semikonduktor yang berfungsi mengubah energi cahaya matahari menjadi energi listrik melalui efek fotovoltaik. Kinerja dan efisiensi daya keluaran panel surya berbanding lurus dengan intensitas cahaya (iradiasi) yang diterima oleh sel fotovoltaik. Namun, kinerja panel surya sangat rentan terhadap soiling effect, yaitu penurunan efisiensi akibat penumpukan kotoran seperti debu, endapan lumpur sisa badai, atau kotoran burung di permukaan kaca pelindung. Lapisan kotoran ini menghalangi foton cahaya matahari untuk mencapai sel silikon, yang pada gilirannya menyebabkan penurunan arus keluaran (Ampere) secara signifikan. Pembersihan secara berkala menjadi prosedur pemeliharaan yang wajib dilakukan agar instalasi panel surya dapat memproduksi daya sesuai dengan kapasitas maksimal yang dirancang.
C. Arsitektur Mikrokontroler STM32F103C8T6 (Blue Pill)
STM32F103C8T6 adalah mikrokontroler berbasis arsitektur 32-bit ARM Cortex-M3. Memiliki kecepatan clock maksimal hingga 72 MHz (diset 8 MHz pada simulasi ini untuk stabilitas), memori Flash 64 KB, dan SRAM 20 KB. Kapasitas komputasi 32-bit memberikan keunggulan telak dibandingkan mikrokontroler 8-bit (seperti Arduino Uno) dalam menangani instruksi kalkulasi matematika yang kompleks. Arsitektur ini memungkinkan STM32 untuk mengeksekusi perhitungan timer mikrodetik (pada sensor ultrasonik), melakukan konversi Analog-to-Digital (ADC) secara simultan (pada sensor arus), serta mengirimkan instruksi I2C tanpa mengalami blocking atau delay pada putaran motor stepper.
D. Kombinasi Multi Sensor dan Koordinasinya
Sistem ini mengandalkan tiga sensor utama yang bekerja sama dalam sebuah arsitektur Sensor Fusion guna mencegah alarm palsu (false positive) dan meningkatkan akurasi sistem pembersih:
Modul LDR Photocell (Sensor Cahaya):
Prinsip Kerja: Menggunakan komponen fotoresistor yang nilai hambatannya turun saat terpapar cahaya. Melalui IC Komparator (misal LM393) pada modul, sensor ini menghasilkan sinyal digital.
Grafik Respon: Berupa sinyal fungsi tangga (Diskrit). Sumbu Y adalah tegangan (0V atau 5V) dan sumbu X adalah waktu. Ketika cahaya tertutup lumpur/debu melampaui batas (threshold) potensiometer, grafik seketika melonjak ke logika 1 (High).
Sensor Arus (Analog - ACS712):
Prinsip Kerja: Memanfaatkan efek Hall (Hall Effect) untuk mengubah aliran elektron dari panel surya menjadi variasi tegangan analog yang proporsional. Tegangan ini dibaca oleh pin ADC STM32.
Grafik Respon: Berupa kurva linier analog. Sumbu Y adalah nilai arus (
$I$ ) dan sumbu X adalah waktu. Jika debu makin tebal, grafik akan menunjukkan penurunan arus secara eksponensial maupun linier hingga berada di bawah ambang batas minimum daya serap.
Sensor Ultrasonik (HC-SR04):
Prinsip Kerja: Mengirimkan gelombang suara 40 kHz (Trigger) dan menghitung waktu pantulannya (Echo). Jarak (
$d$ ) dihitung dengan metode Time of Flight.Grafik Respon: Berupa Linear Threshold. Respon sistem terjadi seketika saat nilai jarak (sumbu Y) memotong garis batas (
$d < 10$ cm) pada sumbu waktu (sumbu X).
Sistem Koordinasi Ketiga Sensor: Ketiga sensor dikoordinasikan menggunakan algoritma conditional berbasis gerbang logika di mikrokontroler:
Logika AND (LDR & Arus): Hanya mengandalkan LDR bisa memicu wiper saat cuaca mendung awan. Oleh karena itu, dikoordinasikan dengan sensor arus. Jika LDR Gelap (1) DAN Arus sangat rendah (< 100mA), maka mikrokontroler memvalidasi bahwa halangan tersebut pasti adalah kotoran/lumpur padat yang menempel di panel, bukan awan gelap.
Logika OR (Ultrasonik): Berperan sebagai interupsi independen. Meskipun cuaca cerah (LDR terang), jika ada benda asing besar seperti ranting atau daun jatuh menutupi panel (Ultrasonik < 10 cm), sistem akan mengabaikan syarat cuaca dan langsung mengaktifkan wiper.
E. Protokol Komunikasi LCD Paralel 8 Bit
Layar LCD standar (berbasis controller HD44780) pada dasarnya berkomunikasi menggunakan protokol paralel 8-bit. Protokol ini membutuhkan setidaknya 11 jalur pin dari mikrokontroler: 8 pin Data (D0 hingga D7) untuk mengirim karakter ASCII atau instruksi heksadesimal, dan 3 pin Kontrol (RS, RW, EN).
RS (Register Select): Logika 0 untuk mengirim Instruksi (misal: clear screen), Logika 1 untuk mengirim Data (karakter huruf).
RW (Read/Write): Logika 0 untuk menulis data ke LCD, Logika 1 untuk membaca data dari LCD.
EN (Enable): Pulsa dari High ke Low untuk memberikan "ketukan" agar LCD mengeksekusi instruksi dari pin data.
Meskipun dalam proyek ini LCD dikendalikan hanya dengan 2 kabel melalui perantara modul I2C (PCF8574), pemahaman terhadap protokol paralel 8-bit tetap menjadi landasan mutlak. Modul I2C (PCF8574) pada dasarnya hanyalah IC Expander yang menerima paket data serial dari STM32, lalu membongkarnya menjadi sinyal paralel 8-bit secara fisik langsung ke kaki-kaki LCD sesuai dengan kaidah komunikasi paralel HD44780.
5. Flowchart Sistem [Kembali]
6. Listing Program [Kembali]
/**
******************************************************************************
* @file : main.c
* @brief : Main program body for Stepper-Driven Solar Wiper Robot
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
uint8_t status_robot = 0; // 0 = Standby/Maju, 1 = Mundur Kembali, 2 = Selesai
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
/* USER CODE BEGIN PFP */
void Stepper_Drive(int direction);
void Stepper_Stop(void);
// === Deklarasi Fungsi LCD 4-Bit ===
void LCD_Send_4Bit(uint8_t data);
void LCD_Enable(void);
void LCD_Cmd(uint8_t cmd);
void LCD_Data(uint8_t data);
void LCD_Init(void);
void LCD_String(char* str);
void LCD_SetCursor(uint8_t row, uint8_t col);
void LCD_Clear(void);
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
// ====================================================================
// FUNGSI MOTOR STEPPER
// ====================================================================
void Stepper_Drive(int direction)
{
static int step_index = 0;
if (direction == 1) {
step_index++;
if (step_index > 3) step_index = 0;
}
else if (direction == -1) {
step_index--;
if (step_index < 0) step_index = 3;
}
switch (step_index)
{
case 0:
HAL_GPIO_WritePin(GPIOB, IN1_DRIVER_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, IN2_DRIVER_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, IN3_DRIVER_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, IN4_DRIVER_Pin, GPIO_PIN_RESET);
break;
case 1:
HAL_GPIO_WritePin(GPIOB, IN1_DRIVER_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, IN2_DRIVER_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, IN3_DRIVER_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, IN4_DRIVER_Pin, GPIO_PIN_RESET);
break;
case 2:
HAL_GPIO_WritePin(GPIOB, IN1_DRIVER_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, IN2_DRIVER_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, IN3_DRIVER_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, IN4_DRIVER_Pin, GPIO_PIN_SET);
break;
case 3:
HAL_GPIO_WritePin(GPIOB, IN1_DRIVER_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, IN2_DRIVER_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, IN3_DRIVER_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, IN4_DRIVER_Pin, GPIO_PIN_SET);
break;
}
}
void Stepper_Stop(void)
{
HAL_GPIO_WritePin(GPIOB, IN1_DRIVER_Pin|IN2_DRIVER_Pin|IN3_DRIVER_Pin|IN4_DRIVER_Pin, GPIO_PIN_RESET);
}
// ====================================================================
// FUNGSI DRIVER LCD 16x2
// ====================================================================
void LCD_Send_4Bit(uint8_t data) {
HAL_GPIO_WritePin(GPIOB, D4_LCD_Pin, ((data >> 0) & 0x01) ? GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, D5_LCD_Pin, ((data >> 1) & 0x01) ? GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, D6_LCD_Pin, ((data >> 2) & 0x01) ? GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, D7_LCD_Pin, ((data >> 3) & 0x01) ? GPIO_PIN_SET : GPIO_PIN_RESET);
}
void LCD_Enable(void) {
HAL_GPIO_WritePin(GPIOB, E_LCD_Pin, GPIO_PIN_SET);
HAL_Delay(1);
HAL_GPIO_WritePin(GPIOB, E_LCD_Pin, GPIO_PIN_RESET);
HAL_Delay(1);
}
void LCD_Cmd(uint8_t cmd) {
HAL_GPIO_WritePin(GPIOB, RS_LCD_Pin, GPIO_PIN_RESET);
LCD_Send_4Bit(cmd >> 4);
LCD_Enable();
LCD_Send_4Bit(cmd);
LCD_Enable();
}
void LCD_Data(uint8_t data) {
HAL_GPIO_WritePin(GPIOB, RS_LCD_Pin, GPIO_PIN_SET);
LCD_Send_4Bit(data >> 4);
LCD_Enable();
LCD_Send_4Bit(data);
LCD_Enable();
}
void LCD_Init(void) {
HAL_Delay(50);
LCD_Cmd(0x02);
LCD_Cmd(0x28);
LCD_Cmd(0x0C);
LCD_Cmd(0x01);
HAL_Delay(2);
LCD_Cmd(0x06);
}
void LCD_String(char* str) {
while(*str) {
LCD_Data(*str++);
}
}
void LCD_SetCursor(uint8_t row, uint8_t col) {
uint8_t address;
if (row == 0) address = 0x80;
else address = 0xC0;
address |= col;
LCD_Cmd(address);
}
void LCD_Clear(void) {
LCD_Cmd(0x01);
HAL_Delay(2);
}
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* MCU Configuration--------------------------------------------------------*/
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
/* USER CODE BEGIN 2 */
Stepper_Stop();
HAL_GPIO_WritePin(GPIOA, POMPA_AIR_Pin, GPIO_PIN_RESET);
// Inisialisasi Layar LCD
LCD_Init();
LCD_SetCursor(0, 0);
LCD_String("SISTEM WIPER");
LCD_SetCursor(1, 0);
LCD_String("SYSTEM READY");
HAL_Delay(2000);
LCD_Clear();
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
uint8_t lcd_state = 99; // Memori untuk sinkronisasi LCD agar tidak berkedip
while (1)
{
// 1. Membaca Sensor Limit Switch
GPIO_PinState kondisi_LimitStop = HAL_GPIO_ReadPin(GPIOB, LIMITSWITCH_STOP_Pin);
GPIO_PinState kondisi_LimitBack = HAL_GPIO_ReadPin(GPIOB, LIMITSWITCH_BACK_Pin);
// 2. Membaca Kondisi Sensor Digital
uint8_t cahaya = HAL_GPIO_ReadPin(GPIOA, PHOTOCELL_Pin); // 1 = Siang, 0 = Malam
uint8_t arus = HAL_GPIO_ReadPin(GPIOA, ACS_Pin); // 1 = Normal, 0 = Turun/Debu
uint8_t ultrasonik = HAL_GPIO_ReadPin(GPIOA, ECHO_SONAR_Pin); // 1 = Ada Benda, 0 = Aman
// ====================================================================
// 3. Evaluasi Berdasarkan Logika Baru (Photocell = Indikator Malam)
// ====================================================================
uint8_t motor_hidup = 0;
// Aturan: Ultrasonic=1 WAJIB hidup dalam kondisi apa pun (Siang/Malam)
if (ultrasonik == 1)
{
motor_hidup = 1;
}
else
{
// Jika Ultrasonic=0, motor HANYA boleh hidup jika SIANG (Cahaya=1) DAN ARUS TURUN (Arus=0)
if (cahaya == 1 && arus == 0)
motor_hidup = 1;
}
{
motor_hidup = 0; // Jika Malam (Cahaya=0) atau Siang tapi Arus Bagus (Arus=1) -> Motor Mati
}
// ================= MANAJEMEN TAMPILAN LCD (SINKRONISASI) =================
uint8_t current_lcd_state = status_robot;
if (status_robot == 0 && motor_hidup == 0) {
current_lcd_state = 10; // Kode khusus mode Standby (Sensor tidak terpenuhi)
}
// Refresh layar LCD HANYA JIKA ADA PERUBAHAN FASE (Mencegah Glitch)
if (lcd_state != current_lcd_state) {
LCD_Clear();
if (current_lcd_state == 10) {
LCD_SetCursor(0, 0); LCD_String("MODE: STANDBY");
LCD_SetCursor(0, 0); LCD_String("MEMBERSIHKAN...");
LCD_SetCursor(1, 0); LCD_String("Pompa Air: ON");
} else if (current_lcd_state == 1) {
LCD_SetCursor(0, 0); LCD_String("RETRACT MUNDUR");
LCD_SetCursor(1, 0); LCD_String("Kembali ke Awal");
} else if (current_lcd_state == 2) {
LCD_SetCursor(0, 0); LCD_String("OPERASI SELESAI");
LCD_SetCursor(1, 0); LCD_String("Panel Bersih!");
}
lcd_state = current_lcd_state; // Simpan memori state saat ini
}
// ================= SIKLUS UTAMA ROBOT =================
// FASE 0: ROBOT BERGERAK MAJU ATAU STANDBY
if (status_robot == 0)
if (motor_hidup == 1)
{
HAL_GPIO_WritePin(GPIOA, POMPA_AIR_Pin, GPIO_PIN_SET); // Relay Pompa ON
Stepper_Drive(1); // Motor Maju
HAL_Delay(15); // Kecepatan & Kestabilan Proteus
}
else
{
HAL_GPIO_WritePin(GPIOA, POMPA_AIR_Pin, GPIO_PIN_RESET); // Relay Pompa OFF
Stepper_Stop(); // Motor Diam
HAL_Delay(15); // PENTING: Mencegah CPU Proteus Freeze
}
// JIKA MENYENTUH LIMIT SWITCH UJUNG PANEL -> MUNDUR
if (kondisi_LimitBack == GPIO_PIN_SET)
{
HAL_GPIO_WritePin(GPIOA, POMPA_AIR_Pin, GPIO_PIN_RESET);
Stepper_Stop();
HAL_Delay(1000); // Pengereman 1 detik
status_robot = 1; // Ganti fase ke Mundur
}
}
// FASE 1: ROBOT RETRACT (MUNDUR KEMBALI KEPANGKAL)
else if (status_robot == 1)
{
HAL_GPIO_WritePin(GPIOA, POMPA_AIR_Pin, GPIO_PIN_RESET);
// JIKA MENYENTUH LIMIT SWITCH PANGKAL -> BERHENTI
if (kondisi_LimitStop == GPIO_PIN_SET)
{
Stepper_Stop();
status_robot = 2; // Ganti fase ke Selesai
}
else
{
Stepper_Drive(-1); // Motor Melangkah Mundur
HAL_Delay(15); // Kecepatan mundur
}
}
// FASE 2: OPERASI SELESAI & RESET KE STANDBY
else if (status_robot == 2)
{
Stepper_Stop();
HAL_GPIO_WritePin(GPIOA, POMPA_AIR_Pin, GPIO_PIN_RESET);
HAL_Delay(3000); // Jeda istirahat 3 detik
}
/* USER CODE END WHILE */
}
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOB, RS_LCD_Pin|E_LCD_Pin|IN1_DRIVER_Pin|IN2_DRIVER_Pin
|IN3_DRIVER_Pin|IN4_DRIVER_Pin|D4_LCD_Pin|D5_LCD_Pin
|D6_LCD_Pin|D7_LCD_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOA, POMPA_AIR_Pin, GPIO_PIN_RESET);
/*Configure GPIO pins : PHOTOCELL_Pin ACS_Pin ECHO_SONAR_Pin */
// Catatan: Pin Trigger_Pin dihilangkan dari input karena tidak dipakai di logicstate/while
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pins : RS_LCD_Pin E_LCD_Pin IN1_DRIVER_Pin IN2_DRIVER_Pin
IN3_DRIVER_Pin IN4_DRIVER_Pin D4_LCD_Pin D5_LCD_Pin
D6_LCD_Pin D7_LCD_Pin */
GPIO_InitStruct.Pin = RS_LCD_Pin|E_LCD_Pin|IN1_DRIVER_Pin|IN2_DRIVER_Pin
|IN3_DRIVER_Pin|IN4_DRIVER_Pin|D4_LCD_Pin|D5_LCD_Pin
|D6_LCD_Pin|D7_LCD_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pins : LIMITSWITCH_STOP_Pin LIMITSWITCH_BACK_Pin */
GPIO_InitStruct.Pin = LIMITSWITCH_STOP_Pin|LIMITSWITCH_BACK_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pin : POMPA_AIR_Pin */
GPIO_InitStruct.Pin = POMPA_AIR_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
void Error_Handler(void)
{
__disable_irq();
while (1)
{
}
}
#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
}
#endif /* USE_FULL_ASSERT */
8. Foto Rangkaian Prototype [Kembali]
10. Kesimpulan dan Saran [Kembali]
Kesimpulan
Sistem robot wiper berhasil dirancang dan dioptimalkan. Implementasi pembacaan kombinasi (sensor fusion) antara LDR Photocell dan Sensor Arus (ACS712) terbukti sangat efektif mencegah aktivasi wiper keliru akibat cuaca mendung (transisi awan), sehingga secara signifikan menghemat daya baterai robot.
Penggunaan motor Bi-Stepper dengan kontrol semi-tertutup menggunakan Limit Switch mekanis sangat ideal untuk membatasi lintasan wiper dan memastikan wiper kembali ke titik nol (home position) dengan akurat.
Melalui pengembangan instrumen ini, pemeliharaan instalasi panel surya milik Bapak Zaini, Ph.D. di Batu Busuk menjadi jauh lebih mandiri, meningkatkan efisiensi daya serap matahari harian masyarakat secara otomatis pasca fenomena alam ekstrim (seperti Galodo).
Saran
Untuk implementasi perangkat keras (hardware) di dunia nyata, sangat disarankan menambahkan modul RTC (Real-Time Clock) agar fungsi pembersihan preventif juga dapat dijadwalkan secara periodik (misalnya 1 minggu sekali).
Sensor Arus yang disimulasikan menggunakan ACS712 dapat ditingkatkan menggunakan modul sensor daya digital I2C (seperti INA219) agar beban pin ADC pada mikrokontroler STM32 berkurang dan pembacaan dayanya lebih kebal terhadap gangguan (noise) elektromagnetik.
11. Download File (File Proteus, Datasheet, dan Library Komponen) [Kembali]
- Datasheet STM 32F103C8T6 [klik disini]
- Datasheet LDR module [klik disini]
- Datasheet Ultrasonic Sensor HC-SR04 [klik disini]
- Datasheet ACS712-20A [klik disini]
- Datasheet Motor Driver l298 [klik disini]
- Datasheet LCD 16x2 LM016L [klik disini]
Komentar
Posting Komentar