Tugas Pendahuluan 1

[KEMBALI KE MENU SEBELUMNYA]

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

1. Prosedur [kembali]

    1. Membuat proyek baru pada STM32CubeIDE dengan memilih mikrokontroler STM32F103C8T6.

    2. Mengonfigurasi peripheral pada STM32CubeMX, yaitu ADC pada PA0, GPIO output untuk LED

        dan buzzer, serta GPIO interrupt pada PA1 untuk push button.

    3. Meng-generate kode dan menuliskan program pembacaan ADC serta perhitungan BPM, kemudian

        melakukan build hingga menghasilkan file .hex.

    4. Membuka Proteus dan membuat rangkaian simulasi menggunakan STM32F103C8T6, LED,

        buzzer, push button, dan sumber sinyal analog sebagai pengganti HeartBeat Sensor.

    5. Menghubungkan pin sesuai konfigurasi, yaitu PA0 ke input analog, PA1 ke push button, serta PB0,

        PB1, PB10, dan PB11 ke LED dan buzzer.

    6. Memasukkan file .hex hasil build dari STM32CubeIDE ke mikrokontroler pada Proteus.

    7. Menguji rangkaian untuk melihat kesesuaiannya dengan kondisi yang diminta.

2. Hardware dan Diagram Blok [kembali]

    A. Hardware

    1. STM32F103C8

    2. Heartbeat Sensor

        SPESIFIKASI :

        - Biometric Pulse Rate or Heart Rate detecting sensor

        - Plug and Play type sensor

        - Operating Voltage: +5V or +3.3V

        - Current Consumption: 4mA

        - Inbuilt Amplification and Noise cancellation circuit.

        - Diameter: 0.625”

        - Thickness: 0.125” Thick

    

    3. Push Button 

    4. LED

    5. Buzzer

    6. Resistor

    B. Diagram Blok

3. Rangkaian Simulasi dan Prinsip Kerja [kembali]

    Prinsip Kerja:

    Rangkaian Heart Rate Indicator bekerja dengan menggunakan sensor heartbeat sebagai pendeteksi

    denyut jantung yang terhubung ke mikrokontroler STM32F103C8T6. Sensor menghasilkan sinyal

    analog yang kemudian dibaca melalui fitur ADC (Analog to Digital Converter) pada pin PA0. Data

    hasil pembacaan diproses dan difilter agar sinyal lebih stabil sebelum dikonversi menjadi nilai BPM

    (Beat Per Minute).

    Nilai BPM diperoleh dari hasil konversi data ADC menggunakan program pada mikrokontroler. Hasil

    pembacaan denyut jantung ditampilkan secara realtime pada Virtual Terminal melalui komunikasi

    UART. Tampilan tersebut memudahkan pengguna untuk memantau nilai ADC, BPM, dan status

    indikator sistem selama simulasi berjalan.

    Sistem dirancang untuk memberikan indikator visual ketika denyut jantung berada pada kondisi

    tertentu. Apabila nilai BPM berada di sekitar 60 BPM, maka LED merah yang terhubung pada pin

    PB10 akan menyala sebagai penanda bahwa kondisi yang ditentukan telah tercapai. Jika nilai BPM

    berada di luar rentang tersebut, LED akan mati kembali.

    Selain itu, rangkaian juga dilengkapi dengan push button dan buzzer sebagai indikator suara. Ketika

    push button ditekan, mikrokontroler akan mendeteksi logika input LOW pada pin PA1 dan

    mengaktifkan buzzer yang terhubung pada pin PB11 sehingga buzzer berbunyi. Saat tombol dilepas,

    buzzer akan kembali mati.

4. Flowchart dan Listing Program [kembali]

    A. Flowchart

    B. Listing Program

    /* USER CODE BEGIN Header */

    /**

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

     * Heart Rate Indicator STM32F103C8T6

     * Kondisi:

     * - Jika BPM sekitar 60 -> LED Merah ON

     * - Jika Push Button ditekan -> Buzzer ON

     * - Data tampil di Virtual Terminal

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

     */

    /* USER CODE END Header */

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

    #include "main.h"

    #include <stdio.h>

    #include <string.h>

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

    ADC_HandleTypeDef hadc1;

    UART_HandleTypeDef huart1;

    /* ================= VARIABLE ================= */

    uint32_t adcValue = 0;

    uint32_t adcFiltered = 0;

    uint8_t beatFlag = 0;

    uint32_t BPM = 0;

    uint32_t threshold = 0;

    uint32_t baseline = 0;

    uint32_t lastBeat = 0;

    uint32_t interval = 0;

    /* ================= FILTER ================= */

    #define FILTER_TOTAL 8

    uint16_t adcBuffer[FILTER_TOTAL];

    uint8_t adcIndex = 0;

    /* ================= PROTOTYPE ================= */

    void SystemClock_Config(void);

    static void MX_GPIO_Init(void);

    static void MX_ADC1_Init(void);

    static void MX_USART1_UART_Init(void);

    uint16_t Filter_ADC(uint16_t input);

    /* ================= FILTER FUNCTION ================= */

    uint16_t Filter_ADC(uint16_t input)

    {

    adcBuffer[adcIndex++] = input;

     if(adcIndex >= FILTER_TOTAL)

     adcIndex = 0;

     uint32_t total = 0;

    for(int i = 0; i < FILTER_TOTAL; i++)

    {

    total += adcBuffer[i];

    }

     return total / FILTER_TOTAL;

    }

    /* ================= printf UART ================= */

    int __io_putchar(int ch)

    {

    HAL_UART_Transmit(&huart1, (uint8_t*)&ch, 1, 100);

    return ch;

    }

    /* ================= MAIN ================= */

    int main(void)

    {

    HAL_Init();

     SystemClock_Config();

    MX_GPIO_Init();

    MX_ADC1_Init();

    MX_USART1_UART_Init();

     char ledStatus[10];

    printf("\r\n===== HEART RATE MONITOR =====\r\n");

     while (1)

    {

    /* ================= BACA ADC ================= */

    HAL_ADC_Start(&hadc1);

     if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)

     {

     adcValue = HAL_ADC_GetValue(&hadc1);

    }

     HAL_ADC_Stop(&hadc1);

     /* ================= FILTER ================= */

    adcFiltered = Filter_ADC(adcValue);

     /* ================= KONVERSI ADC -> BPM ================= */

     BPM = (adcFiltered * 120) / 4095;

    /* ================= THRESHOLD DISPLAY ================= */

    threshold = adcFiltered / 2;

     /* ================= LED MERAH ================= */

     if(BPM >= 58 && BPM <= 62)

    {

    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_SET);

    strcpy(ledStatus, "ON");

    }

    else

    {

    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);

    strcpy(ledStatus, "OFF");

    }

     /* ================= PUSH BUTTON ================= */

     if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)

    {

    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_11, GPIO_PIN_SET);

    }

    else

    {

    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_11, GPIO_PIN_RESET);

    }

     /* ================= SERIAL ================= */

     printf("ADC = %lu | BPM = %lu | Threshold = %lu | LED RED = %s\r\n",

     adcFiltered,

     BPM,

    threshold,

    ledStatus);

     HAL_Delay(20);

     }

    }

    /* ================= 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.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;

    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 ================= */

    static 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.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;

    sConfig.Rank = ADC_REGULAR_RANK_1;

     sConfig.SamplingTime = ADC_SAMPLETIME_71CYCLES_5;

    HAL_ADC_ConfigChannel(&hadc1, &sConfig);

    }

    /* ================= UART ================= */

    static void MX_USART1_UART_Init(void)

    {

    huart1.Instance = USART1;

     huart1.Init.BaudRate = 9600;

    huart1.Init.WordLength = UART_WORDLENGTH_8B;

    huart1.Init.StopBits = UART_STOPBITS_1;

    huart1.Init.Parity = UART_PARITY_NONE;

     huart1.Init.Mode = UART_MODE_TX_RX;

    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;

     huart1.Init.OverSampling = UART_OVERSAMPLING_16;

    HAL_UART_Init(&huart1);

    }

    /* ================= GPIO ================= */

    static void MX_GPIO_Init(void)

    {

    GPIO_InitTypeDef GPIO_InitStruct = {0};

     __HAL_RCC_GPIOA_CLK_ENABLE();

    __HAL_RCC_GPIOB_CLK_ENABLE();

    __HAL_RCC_USART1_CLK_ENABLE();

     /* ===== PA0 ADC ===== */

    GPIO_InitStruct.Pin = GPIO_PIN_0;

    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;

     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* ===== PA1 PUSH BUTTON ===== */

    GPIO_InitStruct.Pin = GPIO_PIN_1;

    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;

    GPIO_InitStruct.Pull = GPIO_PULLUP;

     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* ===== PA9 UART TX ===== */

    GPIO_InitStruct.Pin = GPIO_PIN_9;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;

     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* ===== PA10 UART RX ===== */

    GPIO_InitStruct.Pin = GPIO_PIN_10;

    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;

    GPIO_InitStruct.Pull = GPIO_NOPULL;

     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* ===== PB10 LED ===== */

    /* ===== PB11 BUZZER ===== */

    GPIO_InitStruct.Pin = 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_10 | GPIO_PIN_11,

     GPIO_PIN_RESET);

    }

    /* ================= ERROR ================= */

    void Error_Handler(void)

    {

    __disable_irq();

     while (1)

    {

    }

    }

5. Video Demo [kembali]

6. Kondisi [kembali]

    Kondisi 6: Buatlah rangkaian seperti pada gambar percobaan 1 dengan kondisi Sensor Heartbeat

    membaca BPM 60 , maka LED menyala merah dan ketika push button ditekan Buzzer berbunyi

7. Video Simulasi [kembali]

8. Download File [kembali]

    Download Rangkaian Tugas Pendahuluan 1 disini

    Download Listing Program disini

    Download Datasheet STM32F103C8 disini

    Download Datasheet Heartbeat Sensor disini

[menuju awal]