Langsung ke konten utama

TP 1 MODUL 2 KONDISI 3

DAFTAR ISI

  1. Prosedur
  2. Hardware dan Diagram Blok
  3. Rangkaian Simulasi dan Prinsip Kerja
  4. Flowchart dan Listing Program
  5. Video Demo
  6. Kondisi
  7. Video Simulasi
  8. Download File

HEART RATE INDIKATOR

1. Prosedur [Kembali ke Daftar Isi]

Tujuan 

a) Memahami cara penggunaan PWM, ADC, dan Interrupt pada Development Board yang digunakan 

b) Memahami cara menggunakan komponen input dan output yang mengimplementasikan PWM, ADC, dan Interrupt pada Development Board yang digunakan.

Langkah-Langkah Percobaan

Tahap 1: Perancangan Perangkat Keras (Proteus)

  1. Buka software Proteus dan buat project simulasi baru.

  2. Ambil komponen-komponen yang dibutuhkan melalui Library Manager (tekan tombol P).

  3. Merangkai Output:

    • Pasang 3 buah Resistor (ubah nilai menjadi 220 Ohm) secara seri dengan masing-masing LED (Merah, Hijau, Biru).

    • Hubungkan ujung resistor LED Merah ke pin PB0 pada STM32.

    • Hubungkan ujung resistor LED Hijau ke pin PB1 pada STM32.

    • Hubungkan ujung resistor LED Biru ke pin PB10 pada STM32.

    • Hubungkan terminal positif Buzzer ke pin PB11 pada STM32.

    • Hubungkan semua kaki katoda LED dan kaki negatif Buzzer menjadi satu jalur, lalu sambungkan ke Ground (GND).

  4. Merangkai Input (Simulator Sensor):

    • Pasang komponen Potensiometer (RV2). Hubungkan terminal atas ke sumber tegangan (+3.3V / VCC) dan terminal bawah ke Ground.

    • Tarik kabel dari kaki tengah (wiper) potensiometer dan hubungkan langsung ke pin PA0 pada STM32.

    • Hubungkan juga kabel dari kaki tengah potensiometer tersebut ke pin Test Pin pada komponen Heartbeat Sensor agar animasi jantung dapat berkedip saat simulasi berjalan.

Tahap 2: Pemrograman (STM32CubeIDE)

  1. Buka STM32CubeIDE dan buat project baru. Pilih mikrokontroler STM32F103C8.

  2. Lakukan inisialisasi pin pada mode grafis (atau salin langsung kodingan final yang telah dibuat ke file main.c):

    • Set pin PA0 sebagai ADC1_IN0 (Analog Input).

    • Set pin PB0, PB1, PB10, PB11 sebagai GPIO_Output.

  3. Pada pengaturan ADC, pastikan mode Continuous Conversion Mode diaktifkan (Enable) agar pembacaan potensiometer di Proteus tidak macet.

  4. Masukkan rumus konversi BPM: BPM = (adcValue * 120) / 4095;.

  5. Masukkan logika pengkondisian:

    • BPM 30 - 60: LED Biru menyala (semua indikator lain mati).

    • BPM 60 - 80: LED Hijau menyala (semua indikator lain mati).

    • BPM < 30 ATAU BPM > 80: LED Merah dan Buzzer menyala.

  6. Lakukan proses Build (tekan ikon palu) hingga muncul pesan 0 errors, 0 warnings dan menghasilkan file berekstensi .hex atau .elf.

Tahap 3: Pengujian dan Simulasi

  1. Kembali ke jendela Proteus. Klik dua kali pada komponen mikrokontroler STM32F103C8.

  2. Pada kolom Program File, klik ikon folder dan masukkan file .hex atau .elf yang baru saja dibuat oleh STM32CubeIDE. Klik OK.

  3. Tekan tombol Play (Run Simulation) di pojok kiri bawah layar Proteus.

  4. Ubah nilai persentase pada potensiometer (geser naik atau turun) secara perlahan.

  5. Amati perubahan tegangan (opsional menggunakan Voltmeter DC), perubahan kecepatan kedipan pada sensor, dan respons indikator LED serta Buzzer.

  6. Catat hasil pengamatan sesuai dengan rentang potensiometer yang diatur.

2. Hardware dan Diagram Blok [Kembali ke Daftar Isi]

a. Alat dan Bahan 

 • STM32F103C8T6 
STM32F103C8T6 merupakan mikrokontroler yang berfungsi sebagai pusat kendali sistem. Komponen ini membaca data dari sensor heartbeat, memproses sinyal, lalu mengatur keluaran LED dan buzzer.

 • HeartBeat Sensor 
HeartBeat Sensor berfungsi mendeteksi denyut jantung manusia melalui perubahan aliran darah pada jari atau bagian tubuh tertentu, kemudian mengubahnya menjadi sinyal listrik.

 • Push Button 
 Push Button berfungsi sebagai tombol input manual, misalnya untuk memulai pengukuran, mereset alat, atau mengganti mode kerja.

 • LED 
LED berfungsi sebagai indikator visual kondisi denyut jantung, misalnya normal, rendah, atau tinggi.

 • Buzzer 
Buzzer berfungsi sebagai indikator suara atau alarm apabila denyut jantung berada di luar batas normal.

 • Resistor 
Resistor berfungsi membatasi arus listrik agar LED dan komponen lain tidak rusak, serta sebagai penstabil rangkaian.

 • Breadboard 
Breadboard berfungsi sebagai media perakitan rangkaian sementara tanpa perlu penyolderan sehingga mudah diuji dan dimodifikasi.



3. Rangkaian Simulasi dan Prinsip Kerja [Kembali ke Daftar Isi]



prinsip kerjanya terbagi menjadi empat tahapan utama:

1. Tahap Masukan Sinyal (Input Generation)

Pada perangkat medis asli, sensor akan membaca aliran darah dan menghasilkan sinyal pulsa. Namun, dalam rangkaian simulasi ini, peran tersebut digantikan oleh Potensiometer (RV2).

  • Saat potensiometer diputar, komponen ini bertindak sebagai pembagi tegangan listrik.

  • Ia akan mengeluarkan tegangan listrik yang bervariasi (misalnya dari 0 Volt hingga 3.3 Volt) melalui kaki tengahnya. Tegangan yang berubah-ubah secara mulus inilah yang mewakili "simulasi perubahan detak jantung" dan dikirimkan ke pin PA0 pada mikrokontroler.

2. Tahap Konversi Sinyal (ADC Processing)

Mikrokontroler STM32 adalah perangkat digital murni yang tidak mengerti tegangan analog. Di sinilah fitur ADC (Analog-to-Digital Converter) bekerja.

  • Pin PA0 pada STM32 menerima tegangan analog dari potensiometer.

  • Fitur ADC membaca tegangan tersebut dan menerjemahkannya menjadi angka digital 12-bit (skala dari 0 hingga 4095).

  • Contoh: Jika potensiometer diputar setengah (1.65 Volt), ADC akan menerjemahkannya menjadi angka sekitar 2047.

3. Tahap Pemrosesan Logika (Data Processing & Decision)

Angka digital dari ADC (0 - 4095) kemudian diolah oleh program (kodingan) yang ada di dalam "otak" mikrokontroler (CPU).

  • Konversi ke Satuan BPM: Program mengubah angka raw ADC tadi menjadi rentang Beats Per Minute (0 - 120) menggunakan rumus matematika: BPM = (Nilai ADC * 120) / 4095.

  • Logika Bersyarat (If-Else): Setelah nilai BPM didapat, mikrokontroler akan menyeleksinya sesuai aturan yang telah ditetapkan:

    • Apakah BPM antara 30 - 60? Jika ya, sistem masuk mode Sedih/Lemah.

    • Apakah BPM antara 60 - 80? Jika ya, sistem masuk mode Normal/Tenang.

    • Apakah BPM < 30 atau > 80? Jika ya, sistem masuk mode Abnormal/Bahaya.

4. Tahap Eksekusi (Output Activation)

Berdasarkan hasil keputusan pada tahap logika di atas, mikrokontroler akan mengirimkan perintah berupa arus listrik (3.3V/High) ke pin-pin Port B (PB) untuk menyalakan perangkat keras.

  • Jika mode Sedih/Lemah, arus dikirim ke pin PB10 untuk menyalakan LED Biru.

  • Jika mode Normal/Tenang, arus dikirim ke pin PB1 untuk menyalakan LED Hijau.

  • Jika mode Abnormal/Bahaya, arus dikirim secara bersamaan ke pin PB0 untuk menyalakan LED Merah dan pin PB11 untuk membunyikan Buzzer sebagai peringatan darurat.

4. Flowchart dan Listing Program [Kembali ke Daftar Isi]

Listing Program:

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * Percobaan 1 Heart Rate Indicator
  * Kondisi:
  * Saat sensor mendeteksi keadaan SENANG  -> LED Merah ON
  * Saat sensor berubah ke keadaan SEDIH   -> LED Biru ON
  *
  * Pin:
  * PA0 = Input ADC Sensor Heartbeat
  * PB0 = LED Biru
  * PB1 = LED Hijau
  * PB10 = LED Merah
  * PB11 = Buzzer
  ******************************************************************************
  */
/* USER CODE END Header */

#include "main.h"

/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;

/* USER CODE BEGIN PV */
uint32_t adcValue = 0;

/* batas sensor */
#define BATAS_SENANG 2500
#define BATAS_SEDIH  1500
/* USER CODE END PV */

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);

int main(void)
{
  HAL_Init();
  SystemClock_Config();

  MX_GPIO_Init();
  MX_ADC1_Init();

  while (1)
  {
    /* Baca sensor heartbeat */
    HAL_ADC_Start(&hadc1);
    HAL_ADC_PollForConversion(&hadc1, 100);
    adcValue = HAL_ADC_GetValue(&hadc1);
    HAL_ADC_Stop(&hadc1);

    /* ===============================
       KONDISI SENANG -> LED MERAH
       =============================== */
    if(adcValue > BATAS_SENANG)
    {
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_SET);   // Merah ON
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);  // Biru OFF
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);  // Hijau OFF
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_11, GPIO_PIN_RESET); // Buzzer OFF
    }

    /* ===============================
       KONDISI SEDIH -> LED BIRU
       =============================== */
    else if(adcValue < BATAS_SEDIH)
    {
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET); // Merah OFF
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);    // Biru ON
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);  // Hijau OFF
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_11, GPIO_PIN_SET);   // Buzzer ON
    }

    /* ===============================
       KONDISI NORMAL -> LED HIJAU
       =============================== */
    else
    {
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET); // Merah OFF
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);  // Biru OFF
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_SET);    // Hijau ON
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_11, GPIO_PIN_RESET); // Buzzer OFF
    }

    HAL_Delay(200);
  }
}

/* ================= ADC1 ================= */
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;
  HAL_ADC_Init(&hadc1);

  sConfig.Channel = ADC_CHANNEL_0;     // PA0
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_71CYCLES_5;
  HAL_ADC_ConfigChannel(&hadc1, &sConfig);
}

/* ================= GPIO ================= */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /* Output pin */
  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);
}

/* ================= Clock ================= */
void SystemClock_Config(void)
{
}

/* Error Handler */
void Error_Handler(void)
{
  while(1)
  {
  }
}

5. Video Demo [Kembali ke Daftar Isi]

6. Kondisi [Kembali ke Daftar Isi]

percobaan 1 kondisi 3 :

Buatlah rangkaian seperti pada gambar percobaan 1 dengan kondisi sensor heartbear mendeteksi perubahan dari keadaan senang ke sedih sehingga LED berubah dari merah menjadi biru

7. Video Simulasi [Kembali ke Daftar Isi]



8. Download File [Kembali ke Daftar Isi]

Bagi yang ingin mempelajari lebih lanjut atau mencoba merangkai sendiri, Anda dapat mengunduh file proyek melalui tautan di bawah ini:

Link Video Simulasi

Link Proteus




Komentar

Posting Komentar

Postingan populer dari blog ini

Gambar
                                       BAHAN PRESENTASI UNTUK KULIAH                                                                 ELEKTRONIKA                                                                                                                                         OLEH:    ...
Baca selengkapnya