1. Sediakan alat dan bahan percobaan
2. Rangkailah rangkaian di breadboard
3. Download stlink. dan masukkan listing program ke aplikasi STM32 IDE
4. Hubungkan rangkaian dengan software dengan kabel stlink
5. Jalankan program
.jpeg)
.jpeg)
sistem pendeteksi intensitas cahaya berbasis mikrokontroler PIC16F877A. Rangkaian ini menggunakan sensor LDR (Light Dependent Resistor) yang disusun dengan resistor R2 untuk membentuk pembagi tegangan. Tegangan dari titik tengah pembagi ini dihubungkan ke salah satu pin ADC mikrokontroler (kemungkinan RA0/AN0). Nilai tegangan tersebut akan berubah tergantung pada intensitas cahaya yang diterima LDR, di mana semakin terang cahaya maka tegangan akan semakin rendah, dan sebaliknya.
Mikrokontroler PIC16F877A akan membaca nilai tegangan ini melalui fitur ADC (Analog to Digital Converter). Setelah nilai dikonversi, mikrokontroler akan membandingkan nilai tersebut dengan ambang batas tertentu untuk menentukan apakah kondisi lingkungan terang atau gelap.
Jika kondisi lingkungan terdeteksi gelap (nilai ADC tinggi), maka mikrokontroler akan memberikan sinyal ke pin RC1 untuk mengaktifkan buzzer (BUZ1) sebagai indikator suara. Selain itu, sinyal juga dikirimkan ke pin RC2 yang mengontrol transistor Q1. Ketika Q1 aktif, arus mengalir ke motor DC dan LED D1 melalui resistor R1, sehingga motor dan LED akan menyala. LED D1 berfungsi sebagai indikator visual, sedangkan motor dapat digunakan untuk aplikasi seperti membuka tirai otomatis atau kipas kecil sebagai bentuk respons terhadap kondisi gelap.
Secara keseluruhan, rangkaian ini dirancang untuk merespons perubahan pencahayaan dengan memberikan output berupa suara dari buzzer, nyala LED, dan gerakan motor, yang dikendalikan penuh oleh mikrokontroler berdasarkan pembacaan sensor LDR.
.png)
#include "main.h"
ADC_HandleTypeDef hadc1;
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim2;
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);
static void MX_TIM1_Init(void);
static void MX_TIM2_Init(void);
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_ADC1_Init();
MX_TIM1_Init();
MX_TIM2_Init();
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1); // Motor PWM
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3); // Buzzer PWM
HAL_ADC_Start(&hadc1);
uint8_t buzzer_enabled = 1;
uint32_t last_buzzer_change = 0;
uint8_t buzzer_freq_index = 0;
const uint32_t buzzer_periods[] = {143999, 71999, 47999}; // Frekuensi berbeda
// Threshold (dari rendah → sedang → tinggi)
const uint16_t THRESH_LOW = 1500;
const uint16_t THRESH_MID = 3000;
while (1)
{
HAL_ADC_Start(&hadc1);
HAL_ADC_PollForConversion(&hadc1, 10);
uint32_t adc_val = HAL_ADC_GetValue(&hadc1);
// --- Motor Control ---
if (adc_val < THRESH_LOW)
{
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, 200); // Lambat
}
else if (adc_val < THRESH_MID)
{
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, 600); // Sedang
}
else
{
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, 1000); // Cepat
}
// --- Buzzer Logic ---
if (adc_val < THRESH_LOW && buzzer_enabled)
{
// Ubah frekuensi buzzer setiap 500ms
if (HAL_GetTick() - last_buzzer_change >= 500)
{
last_buzzer_change = HAL_GetTick();
buzzer_freq_index = (buzzer_freq_index + 1) % 3;
uint32_t period = buzzer_periods[buzzer_freq_index];
__HAL_TIM_SET_AUTORELOAD(&htim2, period);
__HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_3, period / 2); // 50% duty
}
}
else
{
}
__HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_3, 0); // Matikan buzzer
// --- Button Logic (PB0 ditekan = nonaktifkan buzzer) ---
if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0) == GPIO_PIN_SET)
{
buzzer_enabled = 0;
__HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_3, 0); // Paksa matikan
buzzer
}
HAL_Delay(10);
}
}
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.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
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;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
{
Error_Handler();
}
PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV2;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
{
Error_Handler();
}
}
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;
if (HAL_ADC_Init(&hadc1) != HAL_OK)
{
Error_Handler();
}
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
}
static void MX_TIM1_Init(void)
{
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
htim1.Instance = TIM1;
htim1.Init.Prescaler = 0;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 65535;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) !=
HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) !=
HAL_OK)
{
Error_Handler();
}
sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
sBreakDeadTimeConfig.DeadTime = 0;
sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) !=
HAL_OK)
{
Error_Handler();
}
HAL_TIM_MspPostInit(&htim1);
}
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
htim2.Instance = TIM2;
htim2.Init.Prescaler = 0;
htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
htim2.Init.Period = 65535;
htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) !=
HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3) !=
HAL_OK)
{
Error_Handler();
}
HAL_TIM_MspPostInit(&htim2);
}
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
/*Configure GPIO pin : PB0 */
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}
void Error_Handler(void)
{
__disable_irq();
while (1)
{
}
}
}
#endif /* USE_FULL_ASSERT */
ANALISA MODUL 2: PWM, ADC, INTERRUPT, & MILLIS1. Analisa bagaimana perbedaan implementasi PWM antara STM32 dan Raspberry Pi Picoserta dampaknya terhadap kontrol motor dan buzzer.Jawab :
PWM (Pulse Width Modulation) pada STM32 dikendalikan oleh hardware timer (TIMx) yang sangat fleksibel. Konfigurasi PWM pada STM32 melalui HAL Library memungkinkan pengguna untuk mengatur frekuensi, duty cycle, mode PWM (edge/center aligned), dan sinkronisasi antar timer. Fitur ini sangat berguna untuk kendali motor presisi tinggi (misalnya BLDC atau servo industri) dan sistem kendali tertanam real-time yang membutuhkan resolusi dan kestabilan sinyal tinggi.Sementara itu, Raspberry Pi Pico menggunakan PWM slice sebanyak 8 buah, dengan masing-masing slice mampu menghasilkan 2 sinyal PWM. Implementasinya di MicroPython sangat sederhana, cukup dengan memanggil beberapa baris kode untuk mengatur frekuensi dan duty cycle. Meskipun Pico menawarkan resolusi 16-bit (lebih tinggi dari STM32 secara default), kontrol terhadap sinkronisasi antar channel dan presisi waktu tidak sekompleks STM32. Oleh karena itu, PWM di Pico lebih cocok untuk aplikasi non-kritis seperti kendali LED, buzzer, atau motor servo skala kecil.
Jadi, STM32 memberikan kontrol yang lebih akurat dan stabil untuk aplikasi kompleks, sedangkan Raspberry Pi Pico lebih unggul dalam kemudahan dan kecepatan pengembangan prototipe.
2. Analisa bagaimana cara pembacaan nilai sensor analog menggunakan ADC pada STM32dan Raspberry Pi PicoJawab :
STM32 memiliki ADC internal multichannel dengan dukungan resolusi hingga 12-bit, sampling rate tinggi, dan metode pembacaan fleksibel: polling, interrupt, atau DMA. Hal ini memungkinkan STM32 untuk membaca data analog dengan cepat, efisien, dan cocok untuk aplikasi real-time seperti sensor suhu, tekanan, atau sensor industri lainnya.
Pada sisi lain, Raspberry Pi Pico menggunakan ADC 12-bit juga, namun hanya tersedia 3 channel aktif (plus satu untuk pembacaan tegangan internal). Dalam MicroPython, pembacaan sangat mudah melalui fungsi
ADC.read_u16(), meskipun hasil pembacaan perlu disesuaikan karena formatnya berupa nilai 16-bit dengan padding. Pico tidak menyediakan opsi DMA atau pengambilan data paralel secara default.Jadi, STM32 lebih fleksibel dan andal untuk aplikasi dengan banyak sensor atau kebutuhan akuisisi data cepat, sedangkan Pico cocok untuk sistem sederhana dengan satu atau dua sensor analog.
3. Analisa bagaimana penggunaan interrupt eksternal dalam mendeteksi input dari sensor atautombo pada STM32 dan Raspberry Pi Pico.Jawab :
Pada STM32, interrupt eksternal ditangani oleh sistem EXTI (External Interrupt/Event Controller) yang dapat mengatur trigger (rising, falling, atau both edges), dan terintegrasi dengan NVIC untuk manajemen prioritas. Penanganannya dilakukan melalui callback HAL, yang membuat sistem lebih modular dan aman untuk aplikasi multitasking dan kendali real-time.
Di Raspberry Pi Pico, interrupt pada pin GPIO diakses melalui fungsi
irq()di MicroPython. Meskipun cukup efektif untuk aplikasi dasar seperti deteksi tombol atau sensor digital, Pico tidak menyediakan manajemen prioritas atau interrupt nesting secara langsung di MicroPython.Jadi, STM32 jauh lebih unggul untuk aplikasi yang membutuhkan interupsi simultan atau kompleks, sedangkan Pico cukup untuk aplikasi sederhana dan reaktif dasar.
4. Analisa bagaimana cara kerja fungsi utime.ticks_ms() pada Raspberry Pi Pico dalam menghitung waktu sejak sistem dinyalakanJawab :
fungsi
utime.ticks_ms()pada Raspberry Pi Pico juga menghasilkan nilai waktu sejak booting dengan satuan milidetik. Namun, karena dijalankan dalam konteks interpreter MicroPython, presisinya bisa terpengaruh oleh beban eksekusi skrip lainnya. saat raspberry pi Pico dinyalakan, sebuah timer tersebut dan mengkonversinya menjadi satuan milidetik. misalnya jika fungsi dipanggil lima detik setelah boot, maka nilainya lkira kira 5000. namun karena keterbatasan ukuran integer (terutama di sistem 32 bit) nilai dari ticks.ms() akan melakukan overflow (kembali ke nol) setelah mencapai batas maksimal, biasanya setiap 249,7 hari (2 milidetik). oleh karena itu, micro pyhton juga menyediakan fungsi seperti untuk menghitung selisih waktu dengan aman meskipun terjadi overflow.5. Analisa bagaimana perbedaan konfigurasi dan kontrol pin PWM serta pemanfaatan timerinternal pada STM32 dan Raspberry Pi Pico dalam menghasilkan sinyal gelombang persegi.Jawab :
PWM di STM32 sangat bergantung pada timer internal yang bisa disinkronkan, dikonfigurasi dalam berbagai mode (PWM mode 1/2, one-pulse mode, output compare, dll), dan dipakai untuk aplikasi seperti motor control, inverter, atau kendali dimmer. Setiap timer dapat memiliki beberapa channel output PWM, sehingga mendukung kendali multi-motor secara simultan.
Sedangkan Raspberry Pi Pico memiliki PWM slice berbasis hardware sederhana. Setiap slice dapat diatur independen namun tidak bisa disinkronisasi atau dipicu oleh sumber eksternal seperti timer pada STM32. Meski mendukung frekuensi tinggi dan duty cycle variatif, Pico tidak dirancang untuk kendali motor presisi tinggi atau sistem PWM kompleks.
Jadi, STM32 unggul dalam kontrol multi-channel presisi tinggi, sedangkan Pico cocok untuk PWM dasar dengan konfigurasi cepat dan mudah.
Kesimpulan
STM32 adalah platform mikrokontroler yang dirancang untuk aplikasi teknis tingkat lanjut, dengan kekuatan di presisi, fleksibilitas konfigurasi, dan dukungan real-time. Cocok digunakan dalam robotika, automasi industri, dan sistem tertanam canggih. Raspberry Pi Pico, sebaliknya, lebih diarahkan untuk kemudahan penggunaan, prototyping cepat, dan pengembangan edukatif. Meski fitur-fiturnya lebih sederhana, Pico tetap efektif untuk membangun konsep awal atau sistem ringan. Praktikum ini memberikan pemahaman praktis bahwa pemilihan platform harus mempertimbangkan kompleksitas aplikasi, kebutuhan real-time, dan kemudahan integrasi.
Download File Analisa klik disiniDownload Video Demo klik disiniDownload Datashett STM32 klik disiniDownload Datasheet Motor stepper klik disini
Download Datasheet RGB-LED klik disiniDownload Datasheet Resistor klik disini
Download Datasheet ULN2003A klik disini
Tidak ada komentar:
Posting Komentar