Laporan Akhir 1
Percobaan 1 Heart Rate Indikator
a. Prosedur [Kembali]
b. Hardware dan Diagram Blok [Kembali]
- Hardwere
Hardware
ST-Link
- Diagram Blok
c. Rangkaian Simulasi dan Prinsip Kerja [Kembali]
- Rangkaian Simulasi
- Prinsip Kerja
Sistem heartrate indikator ini bekerja dengan menggunakan sensor heartbeat untuk mendeteksi denyut jantung, mikrokontroler STM32 sebagai pengolah data, LED sebagai indikator kondisi BPM, dan buzzer sebagai alarm. Sensor heartbeat menghasilkan sinyal analog yang dibaca oleh STM32 melalui pin ADC PA0. Nilai ADC yang terbaca kemudian difilter menggunakan metode moving average agar sinyal lebih stabil dan noise berkurang. Setelah itu sistem membuat baseline adaptif dan threshold untuk mendeteksi puncak denyut jantung. Setiap denyut yang terdeteksi akan dihitung interval waktunya menggunakan fungsi HAL_GetTick(), kemudian nilai BPM dihitung menggunakan rumus 60000 dibagi interval denyut. Jika dalam waktu lebih dari 2 detik tidak ada denyut terdeteksi maka BPM dianggap 0 sehingga semua output dimatikan.
Berdasarkan nilai BPM yang diperoleh, STM32 akan mengendalikan LED dan buzzer sebagai indikator kondisi detak jantung. Jika BPM berada pada rentang 30–60 maka LED kuning menyala yang menandakan detak jantung lambat. Jika BPM berada pada rentang 60–80 maka LED hijau menyala yang menunjukkan kondisi normal. Sedangkan jika BPM lebih dari 80 atau kondisi tidak normal maka LED merah dan buzzer akan menyala sebagai alarm. Sistem juga dilengkapi push button pada pin PA1 yang bekerja menggunakan interrupt eksternal (EXTI). Ketika tombol ditekan, interrupt akan langsung dijalankan untuk mengubah status buzzerOff, sehingga buzzer dapat dimatikan atau alarm di-reset tanpa mengganggu program utama yang tetap berjalan membaca heartbeat sensor secara kontinu.
d. Flowchart dan Listing Program [Kembali]
- Flowchart
- Listing Program
#include "stm32f1xx_hal.h"
/* ================= HANDLE ================= */
ADC_HandleTypeDef hadc1;
/* ================= VARIABLE ================= */
uint32_t adcValue = 0;
uint32_t filteredValue = 0;
uint8_t beatDetected = 0;
uint32_t BPM = 0;
uint32_t lastBeatTime = 0;
uint32_t interval = 0;
uint8_t buzzerOff = 0;
/* ================= FILTER ================= */
#define FILTER_SIZE 10
uint16_t buffer[FILTER_SIZE];
uint8_t indexBuf = 0;
/* ================= PROTOTYPE ================= */
void SystemClock_Config(void);
void MX_GPIO_Init(void);
void MX_ADC1_Init(void);
uint16_t moving_average(uint16_t val);
void LED_Hijau(void);
void LED_Kuning(void);
void LED_Merah(void);
void LED_Mati(void);
void Buzzer_On(void);
void Buzzer_Off(void);
/* ================= FILTER FUNCTION ================= */
uint16_t moving_average(uint16_t val)
{
buffer[indexBuf++] = val;
if (indexBuf >= FILTER_SIZE)
{
indexBuf = 0;
}
uint32_t sum = 0;
for (int i = 0; i < FILTER_SIZE; i++)
{
sum += buffer[i];
}
return sum / FILTER_SIZE;
}
/* ================= LED FUNCTION ================= */
void LED_Hijau(void)
{
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1 | GPIO_PIN_10, GPIO_PIN_RESET);
}
void LED_Kuning(void)
{
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0 | GPIO_PIN_10, GPIO_PIN_RESET);
}
void LED_Merah(void)
{
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0 | GPIO_PIN_1, GPIO_PIN_RESET);
}
void LED_Mati(void)
{
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_10, GPIO_PIN_RESET);
}
/* ================= BUZZER FUNCTION ================= */
void Buzzer_On(void)
{
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_11, GPIO_PIN_SET);
}
void Buzzer_Off(void)
{
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_11, GPIO_PIN_RESET);
}
/* ================= INTERRUPT ================= */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if (GPIO_Pin == GPIO_PIN_1) // PA1
{
buzzerOff = !buzzerOff;
}
}
/* ================= MAIN ================= */
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_ADC1_Init();
uint32_t baseline = 0;
while (1)
{
/* Baca ADC */
HAL_ADC_Start(&hadc1);
HAL_ADC_PollForConversion(&hadc1, 10);
adcValue = HAL_ADC_GetValue(&hadc1);
HAL_ADC_Stop(&hadc1);
/* Filter moving average */
filteredValue = moving_average(adcValue);
/* Baseline adaptif */
baseline = (baseline * 9 + filteredValue) / 10;
uint32_t threshold = baseline + 50;
/* Deteksi detak jantung */
if (filteredValue > threshold && beatDetected == 0)
{
beatDetected = 1;
uint32_t now = HAL_GetTick();
if (lastBeatTime != 0)
{
interval = now - lastBeatTime;
if (interval > 0)
{
BPM = 60000 / interval;
}
}
lastBeatTime = now;
}
if (filteredValue < threshold)
{
beatDetected = 0;
}
/* Timeout jika tidak ada detak */
if (HAL_GetTick() - lastBeatTime > 2000)
{
BPM = 0;
}
/* Output LED dan buzzer */
if (BPM > 0)
{
if (BPM > 30 && BPM < 60)
{
LED_Kuning();
Buzzer_Off();
buzzerOff = 0;
}
else if (BPM >= 60 && BPM <= 80)
{
LED_Hijau();
Buzzer_Off();
buzzerOff = 0;
}
else
{
LED_Merah();
if (!buzzerOff)
{
Buzzer_On();
}
else
{
Buzzer_Off();
}
}
}
else
{
LED_Mati();
Buzzer_Off();
}
HAL_Delay(5);
}
}
/* ================= CLOCK CONFIG ================= */
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.PLL.PLLState = RCC_PLL_NONE;
HAL_RCC_OscConfig(&RCC_OscInitStruct);
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;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);
}
/* ================= ADC CONFIG ================= */
void MX_ADC1_Init(void)
{
ADC_ChannelConfTypeDef sConfig = {0};
__HAL_RCC_ADC1_CLK_ENABLE();
hadc1.Instance = ADC1;
hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
hadc1.Init.ContinuousConvMode = DISABLE;
hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 1;
HAL_ADC_Init(&hadc1);
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME_71CYCLES_5;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
}
/* ================= GPIO CONFIG ================= */
void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
/* PA0 = ADC heartbeat sensor */
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* PA1 = push button interrupt */
GPIO_InitStruct.Pin = GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
HAL_NVIC_SetPriority(EXTI1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(EXTI1_IRQn);
/* PB0, PB1, PB10 = LED | PB11 = buzzer */
GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_10 | GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_10 | GPIO_PIN_11, GPIO_PIN_RESET);
}
e. Video Demo [Kembali]
f. Analisa [Kembali]
g. Download File [Kembali]
File Analisa [Klik disini]
Video Demo [Disini]
Tidak ada komentar:
Posting Komentar