Modul 4 - Project

Perkembangan pemanfaatan Pembangkit Listrik Tenaga Surya (PLTS) sebagai sumber energi terbarukan terus meningkat, termasuk pada wilayah dengan potensi penyinaran matahari yang tinggi seperti Batu Busuk, Kota Padang. Salah satu komponen utama yang menentukan keberhasilan dan kontinuitas operasi sistem PLTS adalah baterai sebagai media penyimpanan energi listrik. Baterai pada sistem PLTS bekerja secara siklus melalui proses pengisian dan pelepasan energi sehingga mengalami penurunan performa seiring waktu. Parameter seperti tegangan, arus, suhu, kapasitas penyimpanan, State of Charge (SOC), dan State of Health (SOH) menjadi indikator penting untuk mengetahui kondisi kesehatan baterai. Apabila kondisi baterai tidak dipantau secara berkala, maka dapat terjadi penurunan efisiensi, percepatan degradasi sel, overcharge, overdischarge, peningkatan temperatur, hingga kerusakan permanen yang berdampak pada umur pakai sistem PLTS secara keseluruhan. Pada penelitian ini digunakan baterai GR-LT-25.6-100 sebagai objek pemantauan karena baterai tersebut banyak digunakan pada sistem penyimpanan energi bertegangan menengah dengan kapasitas yang cukup besar untuk aplikasi PLTS.

Meskipun penggunaan PLTS mulai berkembang di lingkungan masyarakat, tingkat edukasi dan pemahaman mengenai pemeliharaan baterai masih relatif terbatas. Sebagian besar pengguna hanya memanfaatkan energi yang dihasilkan tanpa mengetahui kondisi internal baterai secara aktual. Pemeliharaan sering dilakukan secara reaktif setelah terjadi penurunan performa atau kerusakan, bukan berdasarkan kondisi operasional yang terukur. Di wilayah seperti Batu Busuk, keterbatasan akses terhadap sistem monitoring, minimnya media pembelajaran interaktif, serta kurangnya informasi mengenai indikator kesehatan baterai menyebabkan masyarakat belum memiliki kebiasaan melakukan pemantauan secara preventif. Akibatnya, potensi kerusakan baterai meningkat dan biaya penggantian menjadi lebih besar dibandingkan biaya pemeliharaan sejak dini.

Salah satu alternatif solusi yang dapat diterapkan untuk mengatasi permasalahan tersebut adalah pengembangan sistem monitoring kesehatan baterai berbasis mikrokontroler yang mampu melakukan pengukuran parameter baterai secara real-time. Sistem monitoring memungkinkan pengguna memperoleh informasi kondisi baterai secara langsung sehingga tindakan pemeliharaan dapat dilakukan lebih cepat dan tepat. Dengan memanfaatkan teknologi sensor dan pengolahan data digital, parameter operasional baterai dapat diolah menjadi informasi yang mudah dipahami, seperti persentase kapasitas baterai, tingkat kesehatan baterai, dan kondisi temperatur kerja. Pendekatan ini tidak hanya meningkatkan keandalan sistem PLTS tetapi juga mendukung konsep pemeliharaan berbasis kondisi (condition-based maintenance).

Berdasarkan kebutuhan tersebut, pada proyek praktikum mikroprosesor dan mikrokontroler ini dirancang Sistem Monitoring Kesehatan Baterai PLTS sebagai Media Edukasi dan Pemeliharaan Pencegahan Kerusakan di Batu Busuk, Kota Padang. Sistem yang dikembangkan tidak hanya berfungsi sebagai alat pemantauan teknis, tetapi juga sebagai media edukasi bagi masyarakat untuk memahami perilaku kerja baterai PLTS. Informasi yang ditampilkan secara langsung melalui antarmuka sistem diharapkan dapat meningkatkan kesadaran pengguna terhadap pentingnya pengawasan kondisi baterai. Selain itu, sistem ini dirancang agar dapat menjadi alternatif pembelajaran praktis mengenai hubungan antara perubahan parameter listrik dan kondisi kesehatan baterai sehingga mendukung penerapan energi terbarukan yang lebih berkelanjutan.

Implementasi sistem dilakukan dengan memanfaatkan kombinasi sensor, aktuator, dan pengendali utama yang saling terintegrasi. Mikrokontroler STM32 digunakan sebagai pusat pemrosesan data dan pengendali sistem. Sensor INA219 digunakan untuk membaca arus, tegangan, serta menghitung daya baterai sehingga mendukung estimasi nilai SOC dan SOH. Sensor suhu inframerah GY-906 MLX90614 digunakan untuk melakukan pengukuran temperatur baterai tanpa kontak langsung guna mengurangi risiko gangguan terhadap sistem. Sensor tegangan DC F031-06 dimanfaatkan untuk memperoleh data tegangan baterai secara kontinu sebagai indikator kondisi pengisian dan pelepasan energi. Hasil pembacaan ditampilkan pada LCD LM016L secara real-time sehingga mudah dipahami pengguna. Selain itu, sistem dilengkapi LED indikator dan buzzer sebagai aktuator peringatan ketika parameter baterai berada di luar batas aman, seperti suhu berlebih, penurunan SOH, atau kondisi tegangan abnormal. Integrasi seluruh komponen tersebut diharapkan mampu menghasilkan sistem monitoring yang sederhana, edukatif, dan mendukung pemeliharaan pencegahan pada baterai PLTS.

Tujuan

Merancang dan mengimplementasikan sistem monitoring kesehatan baterai PLTS berbasis mikrokontroler untuk melakukan pembacaan kondisi baterai secara real-time melalui parameter tegangan, daya, dan suhu.
Mengembangkan sistem edukasi pemeliharaan baterai yang mampu menampilkan informasi kondisi operasional dan kesehatan baterai melalui media tampilan sehingga pengguna dapat memahami perubahan kondisi baterai selama penggunaan.
Membangun mekanisme peringatan otomatis menggunakan aktuator berupa indikator visual dan audio sebagai sarana deteksi dini untuk mendukung pemeliharaan pencegahan dan mengurangi potensi kerusakan baterai.

3. Alat dan Komponen [Kembali]

3.1 Alat dan Bahan

Komponen

1.STM32F103C8T6

A.Tabel rentang kerja

B. Tabel batas Input

C. Tabel batas Output

D. Grafik

2. Sensor MLX90614

Grafik respon

3. Sensor Daya INA 219

A.Tabel rentang kerja

B. Tabel batas input dan output

C.Grafik

4. Sensor Tegangan F031-O6

A.Tabel batas rentang kerja

B.tabel batas input

C.Tabel batas output

D.Grafik

5. Baterai Baterai GR-LT-25.6-100

6. Breadboard

7. kabel jumper

8. LCD

9. Potensiometer

10. LED

11. BUZZER

12. Resistor

4. Landasan Teori [Kembali]

2.1 Pembangkit Listrik Tenaga Surya (PLTS)

Pembangkit Listrik Tenaga Surya (PLTS) merupakan sistem pembangkit energi listrik yang memanfaatkan energi radiasi matahari melalui panel surya (photovoltaic) untuk menghasilkan energi listrik. Energi yang dihasilkan panel surya berbentuk arus searah (DC) dan dapat langsung digunakan sebagai sumber daya maupun disimpan ke dalam baterai untuk digunakan pada waktu tertentu.

Sistem PLTS umumnya terdiri dari beberapa komponen utama yaitu panel surya, solar charge controller, baterai penyimpanan energi, inverter, dan beban. Dalam sistem penyimpanan energi, baterai berfungsi menyimpan energi hasil konversi panel surya sehingga kontinuitas suplai listrik tetap terjaga ketika intensitas matahari menurun.

Secara umum, daya keluaran panel surya dapat dihitung menggunakan persamaan:

Keterangan:

P = daya (W)
V = tegangan (Volt)
I = arus (Ampere)

2.2 Sistem Monitoring Kesehatan Baterai

Sistem monitoring kesehatan baterai merupakan sistem yang digunakan untuk memantau kondisi operasional baterai secara real-time berdasarkan parameter tertentu sehingga kondisi baterai dapat diketahui sebelum terjadi kerusakan.

Parameter utama yang digunakan dalam pemantauan kesehatan baterai meliputi:

Tegangan baterai (Voltage)
Arus baterai (Current)
Daya baterai (Power)
Temperatur baterai (Temperature)
State of Charge (SOC)
State of Health (SOH)

Melalui pemantauan parameter tersebut, pengguna dapat melakukan tindakan pemeliharaan preventif sehingga umur baterai dapat dipertahankan.

2.3 Baterai Lithium Iron Phosphate (LiFePO₄)

Baterai GR-LT-25.6-100 yang digunakan pada project ini termasuk jenis Lithium Iron Phosphate (LiFePO₄) dengan tegangan nominal 25,6 V dan kapasitas 100 Ah.

Baterai LiFePO₄ memiliki beberapa keunggulan:

Umur siklus panjang
Stabilitas termal tinggi
Efisiensi pengisian yang baik
Tingkat keamanan lebih tinggi
Perawatan relatif rendah

Karakteristik umum baterai:

Energi tersimpan baterai:

atau:

2.4 Mikrokontroler STM32

STM32 merupakan keluarga mikrokontroler berbasis ARM Cortex-M yang memiliki kemampuan pemrosesan tinggi dengan konsumsi daya rendah.

Pada project ini STM32 digunakan sebagai pusat pengendali sistem yang bertugas:

Membaca data sensor
Mengolah data pengukuran
Menghitung SOC dan SOH
Menampilkan hasil pada LCD
Mengendalikan LED dan buzzer

Keunggulan STM32:

Clock tinggi
ADC presisi tinggi
Mendukung komunikasi I2C, UART, SPI
Konsumsi daya rendah

2.5 Sensor INA219

INA219 merupakan sensor digital yang digunakan untuk mengukur arus, tegangan, dan daya DC.

Sensor ini bekerja menggunakan metode pengukuran shunt resistor, yaitu membaca beda tegangan pada resistor kecil untuk memperoleh nilai arus.

Perhitungan arus:

Perhitungan daya:

Pada project ini INA219 digunakan untuk memonitor konsumsi energi baterai secara real-time.

Grafik sensor INA219

2.6 Sensor Suhu MLX90614

MLX90614 merupakan sensor suhu inframerah non-kontak yang bekerja dengan membaca radiasi inframerah dari objek.

Keunggulan sensor:

Pengukuran tanpa kontak
Respon cepat
Akurasi tinggi
Komunikasi digital I2C

Rentang pengukuran:

Pada project ini sensor digunakan untuk membaca suhu permukaan baterai sehingga kenaikan temperatur dapat terdeteksi lebih awal.

2.7 Sensor Tegangan DC F031-06

Sensor tegangan DC F031-06 digunakan untuk membaca tegangan baterai dan mengubah tegangan tinggi menjadi level aman untuk dibaca ADC mikrokontroler.

Prinsip kerja sensor menggunakan rangkaian pembagi tegangan (voltage divider).

Persamaan:

Sensor ini digunakan untuk mengetahui kondisi pengisian dan pelepasan baterai.

2.8 Komunikasi I2C (Inter Integrated Circuit)

I2C merupakan protokol komunikasi serial yang menggunakan dua jalur komunikasi:

SDA (Serial Data)
SCL (Serial Clock)

Pada project ini komunikasi I2C digunakan antara:

STM32 ↔ INA219
STM32 ↔ MLX90614

Keunggulan I2C:

Jumlah kabel sedikit
Komunikasi cepat
Mendukung banyak perangkat

2.9 State of Charge (SOC)

State of Charge (SOC) merupakan parameter yang menunjukkan persentase kapasitas energi baterai yang masih tersedia.

Rumus pendekatan:

Keterangan:

SOC = kapasitas baterai (%)
Vnow = tegangan saat ini
Vmax = tegangan penuh
Vmin = tegangan minimum

Interpretasi SOC:

80–100% → penuh
50–80% → normal
<50% → perlu pengisian

2.10 State of Health (SOH)

State of Health (SOH) menunjukkan tingkat kesehatan baterai dibanding kapasitas awalnya.

Rumus:

Interpretasi:

SOH > 80% → kondisi baik
SOH 60–80% → mulai menurun
SOH < 60% → perlu penggantian

2.11 LCD 16×2

LCD 16×2 merupakan perangkat tampilan yang digunakan untuk menampilkan informasi secara real-time.

Pada project ini LCD digunakan untuk menampilkan:

Tegangan baterai
Arus
Daya
Suhu
SOC
SOH

2.12 LED dan Buzzer

LED digunakan sebagai indikator visual kondisi sistem.

Fungsi pada project:

LED Biru → indikator kondisi tegangan
LED Merah → indikator kondisi kesehatan baterai
Buzzer → alarm ketika suhu melewati batas aman

2.13 Pemeliharaan Pencegahan (Preventive Maintenance)

Preventive maintenance merupakan metode pemeliharaan yang dilakukan sebelum terjadi kerusakan melalui kegiatan inspeksi dan pemantauan kondisi peralatan.

Dalam project ini, preventive maintenance dilakukan dengan:

Monitoring suhu baterai
Monitoring tegangan
Monitoring kapasitas
Sistem alarm dini

Tujuannya adalah memperpanjang umur baterai dan mengurangi risiko kegagalan sistem PLTS.

5. Flowchart dan Listing Program [Kembali]

Flowchart:

Flowchart sistem menggambarkan urutan kerja perangkat lunak yang berjalan pada mikrokontroler STM32 selama proses monitoring berlangsung. Sistem diawali dengan proses inisialisasi seluruh modul yang terdiri dari LCD, sensor suhu MLX90614, sensor daya INA219, dan sensor tegangan DC. Tahap inisialisasi bertujuan memastikan setiap perangkat dapat berkomunikasi dan berada pada kondisi siap operasi sebelum pengambilan data dimulai.

Setelah proses awal selesai, sistem melakukan pembacaan data suhu menggunakan sensor MLX90614 melalui komunikasi I2C. Data suhu yang diperoleh kemudian diproses dan ditampilkan secara real-time pada LCD. Pada tahap ini sistem juga melakukan evaluasi kondisi suhu untuk menentukan apakah diperlukan aktivasi buzzer sebagai indikator peringatan kepada pengguna. Mekanisme tersebut digunakan sebagai bentuk pemeliharaan preventif agar pengguna mengetahui adanya perubahan kondisi termal pada baterai.

Secara paralel, sistem melakukan inisialisasi dan pembacaan sensor INA219. Sensor ini mengambil informasi listrik berupa tegangan dan arus yang kemudian digunakan untuk memperoleh daya serta menjadi dasar perhitungan kondisi kapasitas baterai atau State of Charge (SOC). Hasil pengolahan ditampilkan pada antarmuka sehingga pengguna dapat memantau kondisi penggunaan energi baterai secara langsung.

Selain itu, sistem juga membaca nilai tegangan melalui sensor DC F031-06. Informasi tegangan digunakan sebagai parameter tambahan untuk mengevaluasi kondisi operasional baterai. Data tersebut kemudian diproses untuk menghasilkan estimasi kondisi kesehatan baterai atau State of Health (SOH). Hasil perhitungan ditampilkan pada LCD agar pengguna memperoleh gambaran kondisi baterai secara menyeluruh.

Sebagai mekanisme peringatan, sistem mengendalikan LED indikator dan buzzer sebagai aktuator. LED digunakan untuk memberikan indikasi visual terhadap kondisi tertentu yang terdeteksi sistem, sedangkan buzzer menghasilkan indikator audio agar perubahan kondisi dapat diketahui secara cepat. Seluruh proses berlangsung berulang secara kontinu sehingga monitoring dapat dilakukan secara real-time.

Listing program

a. main.c

/* USER CODE BEGIN Header */

/**

******************************************************************************

* @file : main.c

* @brief : Main program body

******************************************************************************

/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/

#include "main.h"

/* Private includes ----------------------------------------------------------*/

/* USER CODE BEGIN Includes */

#include <stdint.h>

#include <stdio.h>

/* USER CODE END Includes */

/* Private variables ---------------------------------------------------------*/

ADC_HandleTypeDef hadc1;

ADC_HandleTypeDef hadc2;

I2C_HandleTypeDef hi2c1;

/* USER CODE BEGIN PV */

/* Variabel Pembacaan Sensor Suhu */

float LM35_ADCVoltage = 0.0f;

float LM35_Temperature = 0.0f;

uint8_t LM35_ErrorFlag = 0;

/* Variabel Pembacaan Sensor Tegangan DC */

float F03106_ADCVoltage = 0.0f;

float F03106_BatteryVoltage = 0.0f;

uint8_t F03106_ErrorFlag = 0;

/* Variabel Pembacaan Sensor Arus/Daya INA219 */

float INA219_BusVoltage = 0.0f;

float INA219_ShuntVoltage = 0.0f;

float INA219_Current = 0.0f;

float INA219_Power = 0.0f;

uint8_t INA219_ErrorFlag = 0;

/* Variabel Algoritma Estimasi State of Charge & Health */

uint32_t last_time_ms = 0;

float C_remaining = 10.0f;

float C_actual = 10.0f;

float f_k = 0.0f;

float SoC = 100.0f;

float SoH = 100.0f;

/* Variabel Internal Driver LCD */

uint8_t lcd_rs_state = 0; // 0 untuk Command, 1 untuk Data

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/

void SystemClock_Config(void);

static void MX_GPIO_Init(void);

static void MX_ADC1_Init(void);

static void MX_ADC2_Init(void);

static void MX_I2C1_Init(void);

/* USER CODE BEGIN PFP */

uint16_t LM35_ReadADC(void);

void LM35_ReadTemperature(void);

uint16_t F03106_ReadADC(void);

void F03106_ReadVoltage(void);

void INA219_Init(void);

void Baca_INA219(void);

void Hitung_SOC_SOH(void);

void lcd_enable(void);

void lcd_send4bit(char data);

void lcd_send_cmd(char cmd);

void lcd_send_data(char data);

void lcd_send_string(char *str);

void lcd_put_cur(int row, int col);

void lcd_clear(void);

void lcd_init(void);

/* USER CODE END PFP */

/**

* @brief The application entry point.

* @retval int

int main(void)

{

/* MCU Configuration--------------------------------------------------------*/

HAL_Init();

/* Configure the system clock */

SystemClock_Config();

/* Initialize all configured peripherals */

MX_GPIO_Init();

MX_ADC1_Init();

MX_ADC2_Init();

MX_I2C1_Init();

/* USER CODE BEGIN 2 */

lcd_init(); // Inisialisasi LCD via PCF8574

INA219_Init(); // Inisialisasi Register INA219

// Menampilkan Tampilan Kalibrasi Awal

lcd_clear();

lcd_put_cur(0, 0);

lcd_send_string("SYSTEM READY");

lcd_put_cur(1, 0);

lcd_send_string("CALIBRATING...");

HAL_Delay(2000);

lcd_clear();

// Sinkronisasi basis waktu awal coulomb counting

last_time_ms = HAL_GetTick();

/* USER CODE END 2 */

/* Infinite loop */

/* USER CODE BEGIN WHILE */

while (1)

{

/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */

// 1. Ambil data dari sensor analog & digital

LM35_ReadTemperature(); // Membaca ADC1 (Pin PA0)

F03106_ReadVoltage(); // Membaca ADC2 (Pin PA1)

Baca_INA219(); // Membaca Arus/Daya via I2C

// 2. Kalkulasi Estimasi Status Baterai

Hitung_SOC_SOH();

// 3. Logika Proteksi Aktuator (Blinky / Beep Intermiten)

// Proteksi Suhu (LED-RED di PB13): Berkedip jika suhu < 15C atau > 35C

if (LM35_Temperature > 15.0f && LM35_Temperature < 35.0f) {

HAL_GPIO_WritePin(ACTUATOR_PORT, LED_RED_PIN, GPIO_PIN_RESET);

} else {

HAL_GPIO_TogglePin(ACTUATOR_PORT, LED_RED_PIN);

}

// Proteksi Tegangan (LED-BLUE di PB15): Berkedip jika tegangan < 24.0V atau > 27.6V

if (F03106_BatteryVoltage > 24.0f && F03106_BatteryVoltage < 27.6f) {

HAL_GPIO_WritePin(ACTUATOR_PORT, LED_BLUE_PIN, GPIO_PIN_RESET);

} else {

HAL_GPIO_TogglePin(ACTUATOR_PORT, LED_BLUE_PIN);

}

// Alarm Kesehatan Baterai (Buzzer di PB14): Berbunyi putus-putus jika SoH < 80%

if (SoH >= 80.0f) {

HAL_GPIO_WritePin(ACTUATOR_PORT, BUZZER_PIN, GPIO_PIN_RESET);

} else {

HAL_GPIO_TogglePin(ACTUATOR_PORT, BUZZER_PIN);

}

// 4. Update Informasi Layar LCD (Ditulis langsung tanpa 'clear' agar tidak flicker)

char lcd_baris1[20];

char lcd_baris2[20];

snprintf(lcd_baris1, sizeof(lcd_baris1), "V:%4.1fV T:%4.1fC", F03106_BatteryVoltage, LM35_Temperature);

lcd_put_cur(0, 0);

lcd_send_string(lcd_baris1);

snprintf(lcd_baris2, sizeof(lcd_baris2), "SoH:%3.0f%%", SoH);

lcd_put_cur(1, 0);

lcd_send_string(lcd_baris2);

// Interval pembacaan sistem & kedipan (4Hz)

HAL_Delay(250);

}

/* USER CODE END 3 */

}

/**

* @brief System Clock Configuration

void SystemClock_Config(void)

{

RCC_OscInitTypeDef RCC_OscInitStruct = {0};

RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

RCC_PeriphCLKInitTypeDef PeriphClkInit = {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();

}

PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;

PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV2;

if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)

{

Error_Handler();

}

/**

* @brief ADC1 Configuration (Sensor Suhu LM35 - Channel 0 / Pin PA0)

static void MX_ADC1_Init(void)

{

ADC_ChannelConfTypeDef sConfig = {0};

hadc1.Instance = ADC1;

hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;

hadc1.Init.ContinuousConvMode = DISABLE;

hadc1.Init.DiscontinuousConvMode = DISABLE;

hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;

hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;

hadc1.Init.NbrOfConversion = 1;

if (HAL_ADC_Init(&hadc1) != HAL_OK)

{

Error_Handler();

}

sConfig.Channel = ADC_CHANNEL_0;

sConfig.Rank = ADC_REGULAR_RANK_1;

sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;

if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)

{

Error_Handler();

}

/**

* @brief ADC2 Configuration (Sensor Tegangan F031-06 - Channel 1 / Pin PA1)

static void MX_ADC2_Init(void)

{

ADC_ChannelConfTypeDef sConfig = {0};

hadc2.Instance = ADC2;

hadc2.Init.ScanConvMode = ADC_SCAN_DISABLE;

hadc2.Init.ContinuousConvMode = DISABLE;

hadc2.Init.DiscontinuousConvMode = DISABLE;

hadc2.Init.ExternalTrigConv = ADC_SOFTWARE_START;

hadc2.Init.DataAlign = ADC_DATAALIGN_RIGHT;

hadc2.Init.NbrOfConversion = 1;

if (HAL_ADC_Init(&hadc2) != HAL_OK)

{

Error_Handler();

}

sConfig.Channel = ADC_CHANNEL_1;

sConfig.Rank = ADC_REGULAR_RANK_1;

sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;

if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)

{

Error_Handler();

}

/**

* @brief I2C1 Configuration (LCD & INA219 - Pin PB6 & PB7)

static void MX_I2C1_Init(void)

{

hi2c1.Instance = I2C1;

hi2c1.Init.ClockSpeed = 100000;

hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;

hi2c1.Init.OwnAddress1 = 0;

hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;

hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;

hi2c1.Init.OwnAddress2 = 0;

hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;

hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;

if (HAL_I2C_Init(&hi2c1) != HAL_OK)

{

Error_Handler();

}

/**

* @brief GPIO Configuration (LEDs & Buzzer Output - Pin PB13, PB14, PB15)

static void MX_GPIO_Init(void)

{

GPIO_InitTypeDef GPIO_InitStruct = {0};

__HAL_RCC_GPIOA_CLK_ENABLE();

__HAL_RCC_GPIOB_CLK_ENABLE();

/* Set Output Pins Awal ke Level LOW */

HAL_GPIO_WritePin(ACTUATOR_PORT, LED_RED_PIN|BUZZER_PIN|LED_BLUE_PIN, GPIO_PIN_RESET);

/* Konfigurasi Pin PB13, PB14, PB15 sebagai Output Push-Pull */

GPIO_InitStruct.Pin = LED_RED_PIN|BUZZER_PIN|LED_BLUE_PIN;

GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

GPIO_InitStruct.Pull = GPIO_NOPULL;

GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

HAL_GPIO_Init(ACTUATOR_PORT, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/* ==================== DRIVER SENSOR & ALGORITMA BATERAI ==================== */

uint16_t LM35_ReadADC(void) {

uint16_t adc_raw = 0;

HAL_ADC_Start(&hadc1);

if(HAL_ADC_PollForConversion(&hadc1, 100) == HAL_OK) {

adc_raw = HAL_ADC_GetValue(&hadc1);

LM35_ErrorFlag = 0;

} else {

LM35_ErrorFlag = 1;

}

HAL_ADC_Stop(&hadc1);

return adc_raw;

}

void LM35_ReadTemperature(void) {

uint16_t adc_raw = LM35_ReadADC();

LM35_ADCVoltage = ((float)adc_raw * 3.3f) / 4095.0f;

LM35_Temperature = LM35_ADCVoltage * 100.0f;

LM35_Temperature = (LM35_Temperature * LM35_GAIN) + LM35_OFFSET;

}

uint16_t F03106_ReadADC(void) {

uint16_t adc_raw = 0;

HAL_ADC_Start(&hadc2);

if(HAL_ADC_PollForConversion(&hadc2, 100) == HAL_OK) {

adc_raw = HAL_ADC_GetValue(&hadc2);

F03106_ErrorFlag = 0;

} else {

F03106_ErrorFlag = 1;

}

HAL_ADC_Stop(&hadc2);

return adc_raw;

}

void F03106_ReadVoltage(void) {

uint16_t adc_raw = F03106_ReadADC();

F03106_ADCVoltage = ((float)adc_raw * 3.3f) / 4095.0f;

F03106_BatteryVoltage = F03106_ADCVoltage * F03106_TOTAL_FACTOR;

F03106_BatteryVoltage = (F03106_BatteryVoltage * F03106_VOLT_GAIN) + F03106_VOLT_OFFSET;

}

void INA219_Init(void) {

uint8_t config_buf[2] = {0x39, 0x9F};

if (HAL_I2C_Mem_Write(&hi2c1, INA219_ADDRESS, 0x00, I2C_MEMADD_SIZE_8BIT, config_buf, 2, 100) != HAL_OK) {

INA219_ErrorFlag = 1;

}

HAL_Delay(10);

uint8_t cal_buf[2] = {0x10, 0x00};

if (HAL_I2C_Mem_Write(&hi2c1, INA219_ADDRESS, 0x05, I2C_MEMADD_SIZE_8BIT, cal_buf, 2, 100) != HAL_OK) {

INA219_ErrorFlag = 1;

}

HAL_Delay(10);

}

void Baca_INA219(void) {

uint8_t buf[2];

uint16_t raw_bus, raw_power;

int16_t raw_shunt, raw_current;

INA219_ErrorFlag = 0;

if (HAL_I2C_Mem_Read(&hi2c1, INA219_ADDRESS, 0x02, I2C_MEMADD_SIZE_8BIT, buf, 2, 100) == HAL_OK) {

raw_bus = (buf[0] << 8) | buf[1];

INA219_BusVoltage = ((raw_bus >> 3) * 0.004f) * INA219_DIVIDER_FACTOR;

INA219_BusVoltage = (INA219_BusVoltage * INA219_VOLT_GAIN) + INA219_VOLT_OFFSET;

} else {

INA219_ErrorFlag = 1;

}

if (HAL_I2C_Mem_Read(&hi2c1, INA219_ADDRESS, 0x01, I2C_MEMADD_SIZE_8BIT, buf, 2, 100) == HAL_OK) {

raw_shunt = (int16_t)((buf[0] << 8) | buf[1]);

INA219_ShuntVoltage = raw_shunt * 0.01f;

} else {

INA219_ErrorFlag = 1;

}

if (HAL_I2C_Mem_Read(&hi2c1, INA219_ADDRESS, 0x04, I2C_MEMADD_SIZE_8BIT, buf, 2, 100) == HAL_OK) {

raw_current = (int16_t)((buf[0] << 8) | buf[1]);

INA219_Current = raw_current * 0.0001f;

INA219_Current = (INA219_Current * INA219_CURR_GAIN) + INA219_CURR_OFFSET;

} else {

INA219_ErrorFlag = 1;

}

if (HAL_I2C_Mem_Read(&hi2c1, INA219_ADDRESS, 0x03, I2C_MEMADD_SIZE_8BIT, buf, 2, 100) == HAL_OK) {

raw_power = (buf[0] << 8) | buf[1];

INA219_Power = raw_power * 0.002f;

INA219_Power = (INA219_Power * INA219_POWER_GAIN) + INA219_POWER_OFFSET;

} else {

INA219_ErrorFlag = 1;

}

void Hitung_SOC_SOH(void) {

uint32_t now = HAL_GetTick();

float dt = (float)(now - last_time_ms) / 3600000.0f;

last_time_ms = now;

float delta_Ah = INA219_Current * dt;

float abs_delta_Ah = delta_Ah;

if (abs_delta_Ah < 0.0f) {

abs_delta_Ah = -abs_delta_Ah;

}

float efc = abs_delta_Ah / (2.0f * BATT_KAPASITAS_DESAIN);

float delta_f_cycle = BATT_K_CYCLE * efc;

float delta_f_temp = 0.0f;

if (LM35_Temperature > BATT_T_THRESHOLD) {

delta_f_temp = (LM35_Temperature - BATT_T_THRESHOLD) * BATT_K_TEMP;

}

f_k = f_k + delta_f_cycle + delta_f_temp;

if (f_k < 0.0f) {

f_k = 0.0f;

} else if (f_k > 1.0f) {

f_k = 1.0f;

}

C_actual = BATT_KAPASITAS_DESAIN * (1.0f - f_k);

if (C_actual < 1.0f) {

C_actual = 1.0f;

}

SoH = (C_actual / BATT_KAPASITAS_DESAIN) * 100.0f;

C_remaining = C_remaining - delta_Ah;

if (C_remaining < 0.0f) {

C_remaining = 0.0f;

} else if (C_remaining > C_actual) {

C_remaining = C_actual;

}

SoC = (C_remaining / C_actual) * 100.0f;

}

/* ==================== DRIVER LCD VIA I2C PCF8574 ==================== */

void lcd_enable(void)

{

// Aksi Toggle E dikerjakan langsung secara sekuensial di dalam lcd_send4bit

}

void lcd_send4bit(char data)

{

uint8_t rs = lcd_rs_state ? 0x01 : 0x00; // P0 -> RS

uint8_t backlight = 0x08; // P3 -> Backlight (Always ON)

uint8_t pcf_data = (data << 4) & 0xF0; // Data 4-bit dipetakan ke P4-P7

uint8_t tx_buf[2];

tx_buf[0] = pcf_data | rs | backlight | 0x04; // EN = 1 (P2 -> E set)

HAL_I2C_Master_Transmit(&hi2c1, LCD_ADDR, &tx_buf[0], 1, 100);

HAL_Delay(1);

tx_buf[1] = pcf_data | rs | backlight; // EN = 0 (P2 -> E reset)

HAL_I2C_Master_Transmit(&hi2c1, LCD_ADDR, &tx_buf[1], 1, 100);

HAL_Delay(1);

}

void lcd_send_cmd(char cmd)

{

lcd_rs_state = 0; // Mode Command

lcd_send4bit(cmd >> 4);

lcd_send4bit(cmd & 0x0F);

HAL_Delay(2);

}

void lcd_send_data(char data)

{

lcd_rs_state = 1; // Mode Data

lcd_send4bit(data >> 4);

lcd_send4bit(data & 0x0F);

HAL_Delay(2);

}

void lcd_send_string(char *str)

{

while(*str)

{

lcd_send_data(*str++);

}

void lcd_put_cur(int row, int col)

{

switch(row)

{

case 0: col |= 0x80;

break;

case 1: col |= 0xC0;

break;

}

lcd_send_cmd(col);

}

void lcd_clear()

{

lcd_send_cmd(0x01);

HAL_Delay(2);

}

void lcd_init()

{

HAL_Delay(50);

lcd_send_cmd(0x02); // Mode 4-bit

lcd_send_cmd(0x28); // 2 Baris, Font 5x7

lcd_send_cmd(0x0C); // Display ON, Cursor OFF

lcd_send_cmd(0x06); // Auto increment cursor

lcd_send_cmd(0x01); // Clear LCD

}

/* USER CODE END 4 */

/**

* @brief This function is executed in case of error occurrence.

* @retval None

void Error_Handler(void)

{

/* USER CODE BEGIN Error_Handler_Debug */

__disable_irq();

while (1)

{

}

/* USER CODE END Error_Handler_Debug */

}

b. main.h

/* USER CODE BEGIN Header */

/**

******************************************************************************

* @file : main.h

* @brief : Header untuk file main.c.

* Berisi definisi umum, konstanta sensor, dan pin hardware.

******************************************************************************

/* USER CODE END Header */

/* Define to prevent recursive inclusion -------------------------------------*/

#ifndef __MAIN_H

#define __MAIN_H

#ifdef __cplusplus

extern "C" {

#endif

/* Includes ------------------------------------------------------------------*/

#include "stm32f1xx_hal.h"

/* Private defines -----------------------------------------------------------*/

/* Konstanta Sensor Suhu LM35 */

#define LM35_GAIN 1.0000f

#define LM35_OFFSET 0.0000f

/* Konstanta Sensor Tegangan DC F031-06 */

#define F03106_TOTAL_FACTOR 5.892857f

#define F03106_VOLT_GAIN 1.0000f

#define F03106_VOLT_OFFSET 0.0000f

/* Alamat I2C Komponen */

#define LCD_ADDR (0x27 << 1) // PCF8574 I2C Expander

#define INA219_ADDRESS (0x40 << 1) // Sensor Daya INA219

/* Konstanta Kalibrasi INA219 */

#define INA219_DIVIDER_FACTOR 1.147058f

#define INA219_VOLT_GAIN 1.0000f

#define INA219_VOLT_OFFSET 0.0000f

#define INA219_CURR_GAIN 1.0000f

#define INA219_CURR_OFFSET 0.0000f

#define INA219_POWER_GAIN 1.0000f

#define INA219_POWER_OFFSET 0.0000f

/* Konstanta Algoritma Baterai (SoC & SoH) */

#define BATT_KAPASITAS_DESAIN 10.0f

#define BATT_K_CYCLE 0.0001f

#define BATT_K_TEMP 0.0002f

#define BATT_T_THRESHOLD 35.0f

/* Pemetaan Pin Output Aktuator Sesuai Gambar Skematik */

#define ACTUATOR_PORT GPIOB

#define LED_RED_PIN GPIO_PIN_13 // Terhubung ke Transistor Q6 (LED-RED)

#define BUZZER_PIN GPIO_PIN_14 // Terhubung ke Transistor Q5 (Buzzer)

#define LED_BLUE_PIN GPIO_PIN_15 // Terhubung ke Transistor Q4 (LED-BLUE)

/* Exported functions prototypes ---------------------------------------------*/

void Error_Handler(void);

#ifdef __cplusplus

}

#endif

#endif /* __MAIN_H */

6. Rangkaian dan Prinsip Kerja [Kembali]

Rangkaian versi Simulasi Proteus

Prinsip kerja

Rangkaian simulasi pada Proteus dirancang sebagai representasi sistem monitoring kesehatan baterai PLTS berbasis mikrokontroler STM32. Seluruh komponen diintegrasikan untuk membentuk alur akuisisi data, pemrosesan, dan pemberian informasi kondisi baterai kepada pengguna.

Sumber utama sistem berasal dari baterai PLTS GR-LT-25.6-100 yang menjadi objek pemantauan. Tegangan keluaran baterai diteruskan menuju jalur pengukuran dan beban pengujian berupa lampu. Pada jalur tersebut dipasang resistor shunt yang digunakan oleh sensor INA219 untuk memperoleh data arus yang mengalir pada rangkaian. Sensor INA219 terhubung ke STM32 menggunakan komunikasi I2C melalui jalur SDA dan SCL yang dilengkapi resistor pull-up agar transmisi data berlangsung stabil. Dari hasil pengukuran arus dan tegangan, sistem memperoleh informasi daya yang kemudian digunakan sebagai dasar evaluasi kondisi baterai.

Pengukuran suhu dilakukan menggunakan sensor GY-906 MLX90614 yang bekerja secara inframerah tanpa kontak langsung dengan permukaan baterai. Sensor ini juga menggunakan komunikasi I2C sehingga dapat berbagi jalur komunikasi dengan INA219. Metode non-kontak dipilih untuk menjaga kestabilan pembacaan dan meminimalkan pengaruh pemasangan sensor terhadap kondisi fisik baterai. Data suhu yang diperoleh diproses oleh mikrokontroler dan digunakan sebagai indikator kondisi termal baterai selama operasi.

Selain pengukuran daya dan suhu, sistem menggunakan sensor tegangan DC F031-06 untuk memperoleh data tegangan baterai secara kontinu. Sensor ini memberikan sinyal yang kemudian dibaca oleh STM32 sebagai dasar pemantauan kondisi kerja baterai. Informasi tegangan digunakan bersamaan dengan parameter lain untuk membentuk indikator kesehatan baterai yang ditampilkan kepada pengguna.

Sebagai media interaksi pengguna, sistem menggunakan LCD LM016L yang berfungsi menampilkan parameter monitoring secara real-time. LCD bekerja pada mode komunikasi paralel dan menerima perintah serta data karakter dari STM32. Pengguna dapat melihat informasi kondisi baterai secara langsung tanpa memerlukan perangkat tambahan.

Bagian keluaran sistem terdiri dari LED indikator dan buzzer yang dikendalikan melalui transistor sebagai penguat saklar. Ketika sistem mendeteksi kondisi tertentu berdasarkan hasil pengolahan data sensor, mikrokontroler mengaktifkan aktuator untuk memberikan peringatan visual maupun audio. Dengan integrasi tersebut, rangkaian Proteus tidak hanya berfungsi sebagai alat ukur, tetapi juga sebagai sistem edukasi dan pemeliharaan pencegahan terhadap kondisi kesehatan baterai PLTS.

Cari Blog Ini

Afwan Nasution 231009

Modul 4 - Project

[KEMBALI KE MENU SEBELUMNYA]

KELOMPOK 3

MODUL IV

Sistem Monitoring Kesehatan Baterai PLTS sebagai Media Edukasi dan Pemeliharaan Pencegahan Kerusakan di Batu Busuk, Kota Padang

Komentar

Posting Komentar