MODUL 2 PWM, ADC, INTERRUPT
1. 1. Buka
software proteus lalu rangkai komponen sesuai dengan gambar yang ada di modul
2. 2. Buka
software STM32CubeIDE lalu lakukan konfigurasi pin pada STM untuk
menentukan
GPIO input dan GPIO output
3. 3. Masukan
Program ke dalam software STM32CubeIDE lalu build untuk mendapatkan
file.hex
4. 4. Masukan
file .hex ke dalam file library STM32F103C8 pada proteus
5. 5. Simulasikan
rangkaian
2. Hardware dan Diagram Blok [Kembali]
- ST-LINK
- STM32F103C8 (BLUEPILL)
- HeartBeat Sensor
- Breadboard
- Potensiometer
- Buzzer
- LED RGB
- Resistor 220 OHM
3. Rangkaian Simulasi dan Prinsip Kerja [Kembali]
Rangkaian Simulasi Di Proteus
Prinsip kerja :
Rangkaian pada simulasi tersebut
bekerja sebagai sistem pemantauan detak jantung berbasis mikrokontroler STM32
dengan memanfaatkan sensor heartbeat sebagai input utama, push button sebagai
kontrol tambahan, serta RGB LED dan buzzer sebagai output indikator. Sensor
heartbeat secara kontinu membaca denyut jantung pengguna dan mengubahnya
menjadi nilai BPM (Beats Per Minute), yang kemudian dikirim ke mikrokontroler
untuk diproses. Pada saat yang sama, mikrokontroler juga membaca kondisi push
button untuk mengetahui apakah tombol ditekan atau tidak. Sistem ini dirancang
untuk melakukan pemantauan secara real-time melalui proses pembacaan data yang
berlangsung terus-menerus dalam sebuah loop, sehingga setiap perubahan kondisi
dapat segera dideteksi dan direspons dengan cepat.
Berdasarkan logika yang diterapkan,
ketika nilai BPM yang terdeteksi lebih besar dari 70 dan push button berada
dalam kondisi tidak ditekan, maka mikrokontroler akan mengaktifkan kondisi
peringatan. Dalam kondisi ini, RGB LED akan menyala dengan warna merah sebagai
indikator visual bahwa terjadi kondisi tidak normal, sementara buzzer akan
berbunyi sebagai alarm peringatan. Sebaliknya, apabila nilai BPM berada pada
atau di bawah batas yang ditentukan atau push button ditekan, maka sistem tidak
akan mengaktifkan alarm, sehingga RGB LED tetap mati atau dapat diatur dalam
kondisi normal dan buzzer tidak berbunyi. Dengan demikian, rangkaian ini mampu
memberikan respon otomatis terhadap kondisi detak jantung pengguna secara
efektif dan berkesinambungan.
4. Flowchart dan Listing Program [Kembali]
Flowchart program :
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;
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 ================= */
void LED_Hijau() {
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
}
void LED_Kuning() {
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_SET);
}
void LED_Merah() {
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_SET);
}
void LED_Mati() {
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_10, GPIO_PIN_RESET);
}
/* ================= BUZZER ================= */
void Buzzer_On() { HAL_GPIO_WritePin(GPIOB, GPIO_PIN_11, GPIO_PIN_SET); }
void Buzzer_Off() { 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;
}
}
/* ================= PROTOTYPE ================= */
void SystemClock_Config(void);
void MX_GPIO_Init(void);
void MX_ADC1_Init(void);
/* ================= 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);
/* ==== FILTER ==== */
filteredValue = moving_average(adcValue);
/* ==== BASELINE (ADAPTIF) ==== */
baseline = (baseline * 9 + filteredValue) / 10;
uint32_t threshold = baseline + 50;
/* ==== DETEKSI DETAK ==== */
if(filteredValue > threshold && beatDetected == 0)
{
beatDetected = 1;
uint32_t now = HAL_GetTick();
if(lastBeatTime != 0)
{
interval = now - lastBeatTime;
BPM = 60000 / interval;
}
lastBeatTime = now;
}
if(filteredValue < threshold)
{
beatDetected = 0;
}
/* ==== TIMEOUT ==== */
if(HAL_GetTick() - lastBeatTime > 2000)
{
BPM = 0;
}
/* ==== OUTPUT ==== */
if(BPM > 0)
{
if(BPM > 30 && BPM < 60)
{
LED_Kuning();
Buzzer_Off();
buzzerOff = 0;
}
else if(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 ================= */
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 ================= */
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 ================= */
void MX_GPIO_Init(void)
{
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* PA0 = ADC */
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* PA1 = BUTTON */
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);
/* LED + 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);
}
Percobaan 1 Kondisi 5
Buatlah
rangkaian seperti pada gambar percobaan 1 namun LED diganti dengan LED RGB
dengan logika dasar yang sama
0 komentar:
Posting Komentar