MODUL 2




MODUL 2

PWM,ADC DAN INTERRUPT


1. Pendahuluan[Kembali]

a) Asistensi dilakukan 1x
b) Praktikum dilakukan 1x

2. Tujuan [Kembali]

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

1. STM32 NUCLEO-G474RE

  1. Development Board STM32: 1 buah (Bisa menggunakan STM32F103C8T6 "Blue Pill" atau Nucleo-G474RE sesuai spesifikasi lab).





    Bluepill


    Nucleo

  2. ST-Link V2 / Programmer: 1 buah (Jika menggunakan Blue Pill. Untuk board Nucleo, ST-Link sudah terintegrasi).

    Mengupload: 7281 dari 7281 byte diupload.

  3. Kabel Jumper (Male-to-Male, Male-to-Female): Secukupnya.

  4. Breadboard / Project Board: 1 buah.



  5. LED RGB (Common Cathode/Anode): 1 buah (Bisa diganti dengan 3 LED terpisah: Merah, Hijau, Biru).



  6. Resistor: 3 buah 



  7. Push Button / Toggle Switch: 1 buah.



  8. Active Buzzer (3.3V - 5V): 1 buah.



  9. Modul Sensor HeartBeat: 1 buah.




  10. Potentiometer





1. ADC
ADC atau Analog to Digital Converter merupakan salah satu perangkat elektronika yang digunakan sebagai penghubung dalam pemrosesan sinyal analog oleh sistem digital. Fungsi utama dari fitur ini adalah mengubah sinyal masukan yang masih dalam bentuk sinyal analog menjadi sinyal digital dengan bentuk kode-kode digital. Pada mikrokontroler STM32, terdapat dua ADC (Analog-to-Digital Converter) 12-bit yang masing-masing memiliki hingga 16 kanal eksternal. ADC ini dapat beroperasi dalam mode single-shot atau scan mode. Pada scan mode,konversi dilakukan secara otomatis pada sekelompok input analog yang dipilih. Selain itu, ADC ini memiliki fitur tambahan seperti simultaneous sample and hold, interleaved sample and hold, serta single shunt. ADC juga dapat dihubungkan dengan DMA untuk meningkatkan efisiensi transfer data.Mikrokontroler ini dilengkapi dengan fitur analog watchdog yang memungkinkan pemantauan tegangan hasil konversi dengan akurasi tinggi, serta dapat menghasilkan interupsi jika tegangan berada di luar ambang batas yang telah diprogram. Selain itu, ADC dapat disinkronkan dengan timer internal (TIMx dan TIM1) untuk memulai konversi, pemicu injeksi, serta pemicu DMA, sehingga memungkinkan aplikasi untuk melakukan konversi ADC secara terkoordinasi dengan timer.Pada STM32 Nucleo G474RE, terdapat blok ADC (Analog-to-Digital Converter) yang digunakan untuk mengubah sinyal analog menjadi data digital.STM32 G474RE memiliki beberapa unit ADC (seperti ADC1, ADC2, ADC3, dan ADC4) yang memungkinkan proses konversi dilakukan secara paralel untuk meningkatkan kecepatan akuisisi data. Setiap ADC mendukung resolusi hingga 12-bit, dengan fitur tambahan seperti oversampling untuk meningkatkan akurasi dan mengurangi noise pada sinyal.Setiap unit ADC dapat mengakses banyak channel input yang terhubung ke berbagai pin GPIO, sehingga memungkinkan pembacaan berbagai sensor secara fleksibel. ADC pada STM32 G474RE juga dilengkapi dengan fitur scan mode untuk membaca beberapa channel secara berurutan, serta mode continuous conversion yang memungkinkan pembacaan data secara terus-menerus tanpa intervensi CPU. Selain itu, terdapat injected channel yang berfungsi sebagai channel prioritas untuk kebutuhan real-time.ADC ini juga mendukung berbagai sumber trigger, seperti timer (TIM) atau sinyal eksternal, sehingga dapat disinkronkan dengan modul lain seperti PWM untuk aplikasi kontrol tertutup (closed-loop). Proses konversi dilakukan melalui tahap sampling dan quantization, dengan hasil akhir disimpan pada register data ADC. Dengan fitur-fitur tersebut, ADC pada STM32 G474RE sangat cocok digunakan dalam aplikasi seperti pembacaan sensor, monitoring tegangan, serta sistem kendali berbasis sinyal analog yang membutuhkan kecepatan dan presisi tinggi.

2. PWM
PWM (Pulse Width Modulation) adalah salah satu teknik modulasi dengan mengubah lebar pulsa (duty cylce) dengan nilai amplitudo dan frekuensi yang tetap. Satu siklus pulsa merupakan kondisi high kemudian berada di zona transisi ke kondisi low. Lebar pulsa PWM berbanding lurus dengan amplitudo sinyal asli yang belum termodulasi.Duty Cycle adalah perbandingan antara waktu ON (lebar pulsa High) denganperioda. Duty Cycle biasanya dinyatakan dalam bentuk persen (%).


Duty Cycle= tON / ttotal
Ton= Waktu ON atau Waktu dimana tegangan keluaranberada pada posisi tinggi (high atau 1)
Toff= Waktu OFF atau Waktu dimana tegangan keluaranberada pada posisi rendah (low atau 0)
Ttotal= Waktu satu siklus atau penjumlahan antara Ton dengan Toffatau disebut juga dengan “periode satu gelombang”

PWM pada STM32 dihasilkan menggunakan timer internal yang berfungsi sebagai penghitung waktu dengan berbagai mode operasi. Mikrokontroler ini memiliki empat timer 16-bit (TIM1–TIM4), yang dapat dikonfigurasi untuk menghasilkan sinyal dengan frekuensi dan duty cycle tertentu. Timer bekerja dengan menghitung hingga nilai tertentu berdasarkan frekuensi clock, lalu mengubah status register untuk menghasilkan gelombang persegi.STM32 memiliki 15 pin yang mendukung PWM, beberapa di antaranya berasal dari timer tingkat lanjut seperti TIM1, yang memiliki fitur tambahan seperti complementary output. Selain menghasilkan sinyal PWM, timer juga bisa digunakan untuk mengukur sinyal eksternal (input capture), menghasilkan sinyal berbasis waktu (output compare), dan membuat satu pulsa berdasarkan trigger (one pulse mode). PWM sering digunakan untuk mengontrol kecepatan motor,mengatur kecerahan LED, dan berbagai aplikasi berbasis waktu lainnya.

3. INTERRUPT
Interrupt adalah mekanisme yang memungkinkan suatu instruksi atau perangkat I/O untuk menghentikan sementara eksekusi normal prosesor agar dapat diproses lebih dulu seperti memiliki prioritas tertinggi. Misalnya, saat prosesor menjalankan tugas utama, ia juga dapat terus memantau apakah ada kejadian atau sinyal dari sensor yang memicu interrupt. Ketika terjadi interrupt eksternal, prosesor akan menghentikan sementara tugas utamanya untuk menangani interrupt terlebih dahulu, kemudian melanjutkan eksekusi normal setelah selesai menangani interrupt tersebut. Fungsi yang menangani interrupt disebut Interrupt Service Routine (ISR), yang dieksekusi secara otomatis setiap kali interrupt terjadi.Pada STM32F103C8, semua pin GPIO dapat digunakan sebagai pin interrupt, berbeda dengan Arduino Uno yang hanya memiliki pin tertentu (misalnya pin 2 dan 3). Untuk mengaktifkan interrupt di STM32 menggunakan Arduino IDE, digunakan fungsi attachInterrupt(digitalPinToInterrupt(pin), ISR, mode). Parameter pin menentukan pin mana yang digunakan untuk interrupt, ISR adalah fungsi yang dijalankan saat interrupt terjadi, dan mode menentukan jenis perubahan sinyal yang memicu interrupt. Mode yang tersedia adalah RISING (dari LOW ke HIGH), FALLING (dari HIGH ke LOW), dan CHANGE (baik dari LOW ke HIGH maupun HIGH ke LOW). Saat menggunakan lebih dari satu interrupt secara bersamaan, terkadang perlu memperhatikan batasan tertentu dalam pemrograman.

4. STM32 NUCLEO G474RE
STM32 NUCLEO-G474RE merupakan papan pengembangan (development board) berbasis mikrokontroler STM32G474RET6 yang dikembangkan oleh STMicroelectronics. Board ini dirancang untuk memudahkan proses pembelajaran, pengujian, dan pengembangan aplikasi sistem tertanam (embedded system), baik untuk pemula maupun tingkat lanjut. STM32 Nucleo-G474RE mengintegrasikan antarmuka ST-LINK debugger/programmer secara onboard sehingga pengguna dapat
langsung melakukan pemrograman dan debugging tanpa perangkat tambahan.Adapun spesifikasi dari STM32 NUCLEO-G474RE adalah sebagai berikut:





5.STM32F103C8
STM32F103C8 adalah mikrokontroler berbasis ARM Cortex-M3 yang dikembangkan oleh STMicroelectronics. Mikrokontroler ini sering digunakan dalam pengembangan sistem tertanam karena kinerjanya yang baik, konsumsi daya yang rendah, dan kompatibilitas dengan berbagai protokol komunikasi.Pada praktikum ini, kita menggunakan STM32F103C8 yang dapat diprogram menggunakan berbagai metode, termasuk komunikasi serial (USART), SWD (Serial Wire Debug), atau JTAG untuk berhubungan dengan komputer maupun perangkat lain. Adapun spesifikasi dari STM32F4 yang digunakan dalam praktikum ini adalah sebagai berikut:







5.Percobaan [kembali]

A.Percobaan 1

Rangkaian:


Flowchart:

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 + INTERVAL ==== */
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 (TIDAK ADA DETAK) ==== */
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);
}

B.Percobaan 2

Rangkaian :

Flowchart :

Program :

  • main.c

#include "main.h"
// HANDLE
ADC_HandleTypeDef hadc1;
TIM_HandleTypeDef htim3;
// VARIABLE
uint8_t manual_mode = 0;
uint8_t posisi_servo = 0;
uint8_t last_button = 1;
// THRESHOLD
#define LDR_THRESHOLD 2000
// ================= 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;
HAL_RCC_OscConfig(&RCC_OscInitStruct);
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK |
RCC_CLOCKTYPE_SYSCLK;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);
}
// ================= GPIO =================
void MX_GPIO_Init(void)
{
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitStruct = {0};
// LDR PA0
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
// BUTTON PB1
GPIO_InitStruct.Pin = GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
// SERVO PA6
GPIO_InitStruct.Pin = GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Alternate = GPIO_AF1_TIM3;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}
// ================= ADC =================
void MX_ADC1_Init(void)
{
__HAL_RCC_ADC_CLK_ENABLE();
hadc1.Instance = ADC1;
hadc1.Init.Resolution = ADC_RESOLUTION_12B;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
HAL_ADC_Init(&hadc1);
}
// ================= PWM (FIX SERVO) =================
void MX_TIM3_Init(void)
{
__HAL_RCC_TIM3_CLK_ENABLE();
htim3.Instance = TIM3;
// FIX: 1us tick (assume 48MHz clock)
htim3.Init.Prescaler = 48 - 1;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 20000 - 1; // 20ms = 50Hz (servo standard)
HAL_TIM_PWM_Init(&htim3);
TIM_OC_InitTypeDef sConfigOC = {0};
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 1500; // posisi tengah awal
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1);
}
// ================= SERVO CONTROL =================
void set_servo(uint8_t state)
{
if (state == 0)
{
__HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, 1000); // masuk atap
}
else
{
__HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, 2000); // keluar
atap
}
}
// ================= ADC READ =================
uint16_t read_LDR(void)
{
ADC_ChannelConfTypeDef sConfig = {0};
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = ADC_REGULAR_RANK_1;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
HAL_ADC_Start(&hadc1);
HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
return HAL_ADC_GetValue(&hadc1);
}
// ================= MAIN =================
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_ADC1_Init();
MX_TIM3_Init();
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
while (1)
{
// ===== BUTTON TOGGLE =====
uint8_t button = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
if (last_button == 1 && button == 0)
{
manual_mode = !manual_mode;
posisi_servo = !posisi_servo;
set_servo(posisi_servo);
HAL_Delay(50);
}
last_button = button;
// ===== MODE OTOMATIS =====
if (!manual_mode)
{
uint16_t ldr = read_LDR();
if (ldr < LDR_THRESHOLD)
{
posisi_servo = 0; // mendung → masuk
}
else
{
posisi_servo = 1; // terang → keluar
}
set_servo(posisi_servo);
}
HAL_Delay(100);
}
}
  •  Main.h
#ifndef __MAIN_H
#define __MAIN_H
#include "stm32c0xx_hal.h"
// PIN
#define LDR_PIN GPIO_PIN_0
#define LDR_PORT GPIOA
#define BUTTON_PIN GPIO_PIN_1
#define BUTTON_PORT GPIOB
#define SERVO_PIN GPIO_PIN_6
#define SERVO_PORT GPIOA
// FUNCTION
void SystemClock_Config(void);
void MX_GPIO_Init(void);
void MX_ADC1_Init(void);
void MX_TIM3_Init(void);
#endif

C.Percobaan 3

Rangkaian :

Flowchart :

Program :

#include "main.h"
ADC_HandleTypeDef hadc1;
TIM_HandleTypeDef htim1;
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);
static void MX_TIM1_Init(void);
uint32_t adcValue = 0;
float voltage = 0;
float temperature = 0;
uint8_t system_on = 1;
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_ADC1_Init();
MX_TIM1_Init();
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
while (1)
{
HAL_ADC_Start(&hadc1);
HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
adcValue = HAL_ADC_GetValue(&hadc1);
voltage = ( adcValue / 4095.0) * 3.3;
temperature = ( voltage * 100);
if(system_on)
{
if(temperature >= 27.0)
{
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_RESET);
float duty;
if(temperature >= 35.0)
{
duty = 0.5;
}
else
{
duty = 1.0 - ((temperature - 27.0) / 8.0) * 0.5;
}
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, duty *
65535);
}
else
{
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_RESET);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, 0);
}
}
else
{
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_RESET);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, 0);
}
HAL_Delay(200);
}
}
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.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;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);
PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV2;
HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);
}
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.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);
}
static void MX_TIM1_Init(void)
{
TIM_OC_InitTypeDef sConfigOC = {0};
htim1.Instance = TIM1;
htim1.Init.Prescaler = 0;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 65535;
HAL_TIM_PWM_Init(&htim1);
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1);
HAL_TIM_MspPostInit(&htim1);
}
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_3;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_4;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
HAL_NVIC_SetPriority(EXTI4_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(EXTI4_IRQn);
}
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if(GPIO_Pin == GPIO_PIN_4)
{
system_on = !system_on;
}
}
void Error_Handler(void)
{
__disable_irq();
while (1) {}
}

D.Percobaan 4

Rangkaian :

Flowchart :

Program :

  • main.c

#include "main.h"
// HANDLE
ADC_HandleTypeDef hadc1;
TIM_HandleTypeDef htim3;
// VARIABLE
volatile uint8_t emergency_mode = 0;
uint32_t last_motion_time = 0;
// fallback tombol
uint8_t last_button_state = 1;
// PARAMETER
#define LDR_THRESHOLD 2000
#define MOTION_TIMEOUT 5000
#define LED_OFF 0
#define LED_DIM 100
#define LED_FULL 1000
// ================= 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;
HAL_RCC_OscConfig(&RCC_OscInitStruct);
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK |
RCC_CLOCKTYPE_SYSCLK;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);
}
// ================= GPIO =================
void MX_GPIO_Init(void)
{
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitStruct = {0};
// PIR → PA1
GPIO_InitStruct.Pin = GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
// BUTTON → PB1 (PULL-UP + INTERRUPT)
GPIO_InitStruct.Pin = GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
// LED PWM → PA6
GPIO_InitStruct.Pin = GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
GPIO_InitStruct.Alternate = GPIO_AF1_TIM3;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
// IRQ untuk PB1 (EXTI0_1)
HAL_NVIC_SetPriority(EXTI0_1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(EXTI0_1_IRQn);
}
// ================= ADC =================
void MX_ADC1_Init(void)
{
__HAL_RCC_ADC_CLK_ENABLE();
hadc1.Instance = ADC1;
hadc1.Init.Resolution = ADC_RESOLUTION_12B;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
hadc1.Init.ContinuousConvMode = DISABLE;
HAL_ADC_Init(&hadc1);
ADC_ChannelConfTypeDef sConfig = {0};
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = ADC_REGULAR_RANK_1;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
}
// ================= PWM =================
void MX_TIM3_Init(void)
{
__HAL_RCC_TIM3_CLK_ENABLE();
htim3.Instance = TIM3;
htim3.Init.Prescaler = 64;
htim3.Init.Period = 1000;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_PWM_Init(&htim3);
TIM_OC_InitTypeDef sConfigOC = {0};
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1);
}
// ================= INTERRUPT =================
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if (GPIO_Pin == GPIO_PIN_1)
{
emergency_mode = !emergency_mode;
}
}
// ================= HELPER =================
uint16_t read_LDR(void)
{
HAL_ADC_Start(&hadc1);
HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
return HAL_ADC_GetValue(&hadc1);
}
void set_LED(uint16_t value)
{
__HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, value);
}
// ================= MAIN =================
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_ADC1_Init();
MX_TIM3_Init();
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
while (1)
{
// ===== FALLBACK BUTTON =====
uint8_t current_button = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
if (last_button_state == 1 && current_button == 0)
{
emergency_mode = !emergency_mode;
HAL_Delay(50);
}
last_button_state = current_button;
// ===== MODE DARURAT =====
if (emergency_mode)
{
set_LED(LED_OFF);
continue;
}
uint16_t ldr = read_LDR();
uint8_t pir = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1);
// SIANG
if (ldr < LDR_THRESHOLD)
{
set_LED(LED_OFF);
}
else
{
// MALAM
if (pir == GPIO_PIN_SET)
{
last_motion_time = HAL_GetTick();
}
if (HAL_GetTick() - last_motion_time < MOTION_TIMEOUT)
{
set_LED(LED_FULL);
}
else
{
set_LED(LED_DIM);
}
}
HAL_Delay(100);
}
}

  • main.h

#ifndef __MAIN_H
#define __MAIN_H
#include "stm32c0xx_hal.h"
// ================= PIN DEFINITIONS =================
// LDR (ADC)
#define LDR_PORT GPIOA
#define LDR_PIN GPIO_PIN_0 // PA0
// PIR SENSOR
#define PIR_PORT GPIOA
#define PIR_PIN GPIO_PIN_1 // PA1
// PUSH BUTTON (INTERRUPT)
#define BUTTON_PORT GPIOB
#define BUTTON_PIN GPIO_PIN_1 // PB1
// LED PWM
#define LED_PORT GPIOA
#define LED_PIN GPIO_PIN_6 // PA6 (TIM3_CH1)
// ================= FUNCTION PROTOTYPES =================
void SystemClock_Config(void);
void MX_GPIO_Init(void);
void MX_ADC1_Init(void);
void MX_TIM3_Init(void);
#endif


Tidak ada komentar:

Posting Komentar

Langganan: Komentar (Atom)

                                            BAHAN PRESENTASI UNTUK MATA KULIAH  ELEKTRONIKA 2024   Nama : Muhammad Fadhil Dwi Kesuma NIM : 2...

  • (tanpa judul)
                                                BAHAN PRESENTASI UNTUK MATA KULIAH  ELEKTRONIKA 2024   Nama : Muhammad Fadhil Dwi Kesuma NIM : 2...