LA 1 M2
[menuju akhir]
.jpeg)
.jpeg)
.jpeg)
Laporan Akhir - Percobaan 8
1. Prosedur [kembali]
1. Menentukan Komponen yang Digunakan, yaitu STM32 Board (STM32F103C8T6), Motor DC, Stepper Motor, Modul Sensor Touch, Potentiometer, Resistor, Transistor (untuk kontrol motor DC), ST-Link Programmer, Kabel Jumper dan Breadboard
2. Konfigurasi Pin pada STM32CubeIDE
Motor DC: Pilih pin GPIO untuk PWM motor.
Stepper Motor: Pilih pin GPIO untuk IN1, IN2, IN3, IN4.
Sensor Touch: Pilih pin GPIO untuk input.
Potentiometer: Pilih pin ADC untuk pembacaan analog.
Transistor: Pilih pin GPIO untuk mengontrol transistor.
3. Setup di STM32CubeIDE
Buat proyek baru dan pilih STM32 model yang sesuai. Atur pin GPIO untuk motor, stepper, sensor touch, dan potentiometer. Set pin motor dan stepper ke mode output, sensor touch dan potentiometer ke input atau analog.
4. Program di STM32CubeIDE
Tulis kode untuk kontrol motor DC menggunakan PWM, kontrol stepper, dan pembacaan sensor touch. Gunakan ADC untuk membaca nilai dari potentiometer.
5. Hubungkan STM32 ke Laptop
Sambungkan STM32 ke laptop menggunakan ST-Link. Pastikan ST-Link terdeteksi di STM32CubeIDE.
6. Build dan Run Program
Build proyek dan upload ke STM32 melalui ST-Link. Jalankan program dan verifikasi kontrol motor dan stepper sesuai dengan input sensor touch.
7. Verifikasi dan Pengujian
Pastikan motor DC dan stepper motor berfungsi sesuai dengan input yang diterima dari sensor touch dan potentiometer.
2. Hardware dan Diagram Blok [kembali]
a. Hardware
1) Laptop yang sudah terinstal Software STM32
2) ST Link (Port sambungan kabel dari laptop ke STM32)
3) White Board atau Project Board
.jpeg)
4) STM 32
5) Motor Servo
6) Resistor
.jpeg)
7) Jumper
.jpeg)
8) Sensor Touch
9) Potensiometer
10) Transistor
11) Stepper
b. Blok Diagram
a. Rangkaian
Prinsip Kerja:
Prinsip kerja dari percobaan ini adalah mengendalikan stepper motor dan motor DC menggunakan STM32 berbasis input dari sensor sentuh (touch sensor) dan potentiometer. Pin PB0 digunakan untuk sensor touch sebagai input digital. Ketika sensor tidak disentuh (logika low), STM32 akan membaca nilai analog dari potentiometer melalui ADC di channel 0 (biasanya pin PA0). Nilai ini digunakan untuk menentukan arah putaran stepper motor: jika nilai ADC < 2048 maka stepper berputar searah jarum jam (CW), jika ≥ 2048 maka berputar berlawanan arah jarum jam (CCW). Stepper dikontrol melalui 4 pin output (PB8–PB11) yang diatur secara bergantian untuk menghasilkan gerakan motor.
Saat sensor disentuh (logika high), interupsi EXTI dipicu, dan callback `HAL_GPIO_EXTI_Callback()` menyalakan motor DC melalui pin PB7 serta mematikan stepper motor (semua coil dimatikan). Ini artinya hanya salah satu motor yang aktif dalam satu waktu: jika tidak disentuh → stepper berjalan sesuai potentiometer; jika disentuh → motor DC menyala, stepper berhenti.
Transistor yang terhubung di motor DC berfungsi memperkuat arus PWM dari mikrokontroler agar motor bisa berjalan dengan aman. Sistem bekerja secara loop di fungsi `main()`, dengan monitoring terus-menerus terhadap kondisi sensor dan pembacaan nilai potentiometer untuk kontrol dinamis.
a. Flowchart
b. Listing Program
#include "stm32f1xx_hal.h"
// Konfigurasi Hardware
#define STEPPER_PORT GPIOB
#define IN1_PIN GPIO_PIN_8
#define IN2_PIN GPIO_PIN_9
#define IN3_PIN GPIO_PIN_10
#define IN4_PIN GPIO_PIN_11
#define TOUCH_SENSOR_PORT GPIOB
#define TOUCH_SENSOR_PIN GPIO_PIN_0
#define MOTOR_DC_PORT GPIOB
#define MOTOR_DC_PIN GPIO_PIN_7
// Mode Stepper
const uint8_t STEP_SEQ_CW[4] = {
(1<<0), // IN1
(1<<1), // IN2
(1<<2), // IN3
(1<<3) // IN4
};
const uint8_t STEP_SEQ_CCW[4] = {
(1<<3), // IN4
(1<<2), // IN3
(1<<1), // IN2
(1<<0) // IN1
};
ADC_HandleTypeDef hadc1;
uint8_t current_mode = 0; // 0=CW, 1=CCW
volatile uint8_t touch_state = 0;
void SystemClock_Config(void);
void MX_GPIO_Init(void);
void MX_ADC1_Init(void);
void RunStepper(const uint8_t *sequence, uint8_t speed);
void Error_Handler(void);
int main(void) {
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_ADC1_Init();
while (1) {
// Saat tidak disentuh, jalankan stepper seperti biasa
if (HAL_GPIO_ReadPin(TOUCH_SENSOR_PORT, TOUCH_SENSOR_PIN) == GPIO_PIN_RESET) {
HAL_ADC_Start(&hadc1);
if (HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK) { uint16_t adc_val = HAL_ADC_GetValue(&hadc1);
current_mode = (adc_val < 2048) ? 0 : 1; // 0 = CW, 1 = CCW
}
if (current_mode == 0) { RunStepper(STEP_SEQ_CW, 5);
} else {
RunStepper(STEP_SEQ_CCW, 5);
}
}
HAL_Delay(1);
}
}
void RunStepper(const uint8_t *sequence, uint8_t speed) {
static uint8_t step = 0;
HAL_GPIO_WritePin(STEPPER_PORT, IN1_PIN, (sequence[step] & (1<<0)) ?
GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(STEPPER_PORT, IN2_PIN, (sequence[step] & (1<<1)) ?
GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(STEPPER_PORT, IN3_PIN, (sequence[step] & (1<<2)) ?
GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(STEPPER_PORT, IN4_PIN, (sequence[step] & (1<<3)) ?
GPIO_PIN_SET : GPIO_PIN_RESET);
step = (step + 1) % 4;
HAL_Delay(speed);
}
void MX_GPIO_Init(void) {
GPIO_InitTypeDef GPIO_InitStruct = {0};
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_AFIO_REMAP_SWJ_NOJTAG(); // Optional: disable JTAG to free PB3-PB4 if needed
// Konfigurasi Touch Sensor sebagai input dengan EXTI (interrupt)
GPIO_InitStruct.Pin = TOUCH_SENSOR_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(TOUCH_SENSOR_PORT, &GPIO_InitStruct);
// Aktifkan NVIC untuk EXTI0
HAL_NVIC_SetPriority(EXTI0_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
// Konfigurasi Motor DC (PB7) GPIO_InitStruct.Pin = MOTOR_DC_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(MOTOR_DC_PORT, &GPIO_InitStruct);
// Konfigurasi Stepper Motor (PB8-PB11)
GPIO_InitStruct.Pin = IN1_PIN | IN2_PIN | IN3_PIN | IN4_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(STEPPER_PORT, &GPIO_InitStruct);
}
void MX_ADC1_Init(void) {
ADC_ChannelConfTypeDef sConfig = {0};
hadc1.Instance = ADC1;
hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
hadc1.Init.ContinuousConvMode = DISABLE;
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_71CYCLES_5;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) { Error_Handler();
}
}
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;
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();
}
}
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
if (GPIO_Pin == TOUCH_SENSOR_PIN) {
GPIO_PinState pinState = HAL_GPIO_ReadPin(TOUCH_SENSOR_PORT, TOUCH_SENSOR_PIN);
if (pinState == GPIO_PIN_SET) {
// Touch sensor ditekan - nyalakan motor DC, matikan stepper
HAL_GPIO_WritePin(MOTOR_DC_PORT, MOTOR_DC_PIN, GPIO_PIN_SET);
HAL_GPIO_WritePin(STEPPER_PORT, IN1_PIN|IN2_PIN|IN3_PIN|IN4_PIN, GPIO_PIN_RESET);
} else {
// Touch sensor dilepas - matikan motor DC
HAL_GPIO_WritePin(MOTOR_DC_PORT, MOTOR_DC_PIN, GPIO_PIN_RESET);
}
}
}
// IRQ Handler untuk EXTI0
void EXTI0_IRQHandler(void) {
HAL_GPIO_EXTI_IRQHandler(TOUCH_SENSOR_PIN);
}
void Error_Handler(void) {
while(1) {}
}
1. Analisa bagaimana perbedaan implementasi PWM antara STM32 dan Raspberry Pi Pico serta dampaknya terhadap kontrol motor dan LED.
Jawab:
Berdasarkan saat praktikum, terdapat dua mikrokontroler yang dibandingkan, yaitu STM32 dan Raspberry Pi Pico, yang masing-masing memiliki karakteristik berbeda dalam implementasi PWM.
STM32 dikenal memiliki modul PWM berbasis hardware yang kuat dan presisi, sehingga sangat ideal untuk aplikasi yang memerlukan kontrol ketat seperti motor DC. Dalam percobaan yang dilakukan, STM32 dihubungkan dengan motor DC yang dikendalikan melalui input dari touch sensor. Ketika touch sensor ditekan, motor DC dinyalakan, dan saat touch sensor dilepas kembali, motor DC dimatikan. Ini menunjukkan bahwa STM32 mampu memproses input secara real-time dan memberikan respon cepat serta stabil. Kemampuan PWM yang presisi memungkinkan kontrol kecepatan dan daya motor berjalan halus, yang sangat penting untuk mencegah kerusakan dan menjaga performa motor tetap optimal. Dengan kata lain, PWM STM32 sangat cocok untuk aplikasi industri atau robotik yang memerlukan kontrol motor yang akurat dan andal.
Sementara itu, Raspberry Pi Pico memiliki PWM yang juga mumpuni namun lebih sederhana dan biasanya digunakan untuk aplikasi yang tidak memerlukan ketelitian tinggi, seperti pengendalian LED atau buzzer. Dalam percobaan ini, Raspberry Pi Pico digunakan untuk memonitor suhu dan kelembapan. Berdasarkan hasil pembacaan sensor, Pico akan memutuskan untuk memainkan melodi tertentu melalui buzzer. Jika suhu lebih dari 35°C dan kelembapan lebih dari 50%, buzzer akan memainkan nada peringatan gabungan; jika hanya suhu yang tinggi, buzzer memainkan melodi suhu tinggi; jika hanya kelembapan yang tinggi, buzzer memainkan melodi kelembapan tinggi; dan jika semua normal, buzzer dimatikan. Di sini, PWM digunakan untuk mengatur frekuensi nada buzzer yang keluar. Meskipun PWM Pico tidak sepresisi STM32, untuk tugas ringan seperti ini, Pico tetap mampu menjalankan fungsinya dengan baik. Perbedaan utama yang terlihat adalah Pico lebih cocok untuk aplikasi monitoring yang sederhana dan tidak memerlukan kontrol daya yang berat, karena PWM-nya lebih dioptimalkan untuk output ringan.
Dari perbandingan ini dapat disimpulkan bahwa STM32 unggul dalam hal presisi dan kecepatan respons karena PWM-nya didukung langsung oleh hardware timer, yang memungkinkan kontrol perangkat berat seperti motor berjalan optimal dan aman. Sebaliknya, Raspberry Pi Pico lebih cocok untuk aplikasi yang bersifat indikator atau alarm, di mana PWM cukup digunakan untuk mengatur LED atau buzzer tanpa memerlukan ketelitian yang tinggi. Perbedaan implementasi ini berdampak signifikan terhadap hasil akhir; STM32 mampu mengendalikan motor dengan mulus dan cepat sesuai perubahan input sensor, sementara Raspberry Pi Pico lebih fokus pada pemberian notifikasi suara sesuai hasil monitoring lingkungan. Dengan demikian, pilihan mikrokontroler harus disesuaikan dengan kebutuhan aplikasi; STM32 untuk kontrol presisi tinggi, dan Raspberry Pi Pico untuk pengendalian sederhana.
2. Analisa bagaimana cara pembacaan nilai sensor analog menggunakan ADC pada STM32 dan Raspberry Pi Pico
Jawab:
Dalam percobaan yang dilakukan, STM32 menunjukkan kemampuannya dalam pembacaan nilai sensor analog menggunakan ADC dengan cepat dan responsif. Ketika touch sensor tidak disentuh, STM32 menjalankan stepper motor, namun begitu touch sensor ditekan, nilai ADC berubah dan motor DC langsung menyala, sementara stepper motor dimatikan. Hal ini menunjukkan bahwa ADC 12-bit pada STM32 mampu mengonversi sinyal analog menjadi nilai digital dalam rentang 0 hingga 4095 secara cepat dan akurat, sangat cocok untuk aplikasi yang memerlukan kontrol dinamis. STM32 juga dapat melakukan pembacaan serentak dari beberapa saluran ADC menggunakan fitur scan mode, serta mendukung DMA (Direct Memory Access) untuk mengakses data tanpa membebani prosesor utama. Ini memberikan kestabilan dan presisi yang diperlukan dalam aplikasi seperti pengendalian motor.
Sementara itu, pada Raspberry Pi Pico, pembacaan nilai sensor analog dilakukan menggunakan ADC 12-bit yang juga mengubah sinyal analog menjadi nilai digital dalam rentang yang sama, 0 hingga 4095. Percobaan yang dilakukan dengan Pico terkait dengan pembacaan suhu dan kelembapan, di mana jika kedua nilai tersebut melebihi ambang batas, buzzer akan aktif dengan memainkan melodi yang sesuai. Meskipun Pico dapat melakukan pembacaan ADC menggunakan Python, Pico hanya memiliki tiga pin ADC (ADC0, ADC1, dan ADC2), yang berarti pembacaan dari beberapa sensor harus dilakukan secara bergantian. Proses pembacaan ini lebih sederhana dan cukup efektif untuk aplikasi monitoring seperti suhu dan kelembapan, namun tanpa fitur tambahan seperti DMA atau oversampling, Pico terbatas dalam hal akurasi dan kecepatan pembacaan pada aplikasi yang lebih kompleks atau saat banyak sensor perlu dibaca bersamaan.
Secara keseluruhan, STM32 lebih unggul dalam hal kecepatan, presisi, dan kemampuan untuk menangani pembacaan dari banyak sensor secara bersamaan, menjadikannya pilihan tepat untuk aplikasi yang memerlukan kontrol perangkat yang dinamis dan cepat. Sementara itu, Raspberry Pi Pico meskipun efektif untuk aplikasi monitoring yang lebih sederhana, memiliki keterbatasan dalam hal kecepatan respon dan kemampuan pembacaan sensor secara bersamaan, membuatnya lebih cocok untuk aplikasi yang tidak memerlukan pembacaan sensor dalam waktu yang sangat cepat.
3. Analisa bagaimana penggunaan interrupt eksternal dalam mendeteksi input dari sensor atau tombo pada STM32 dan Raspberry Pi Pico.
Jawab:
Pada percobaan STM32 yang menggunakan motor DC, stepper motor, dan sensor touch, interrupt eksternal dimanfaatkan untuk mendeteksi input dari sensor touch secara real-time. Sensor touch yang terhubung ke pin PB0 dikonfigurasi sebagai input dengan mode interrupt eksternal menggunakan fitur EXTI (External Interrupt/Event Controller) bawaan STM32. Ketika sensor disentuh atau dilepas, terjadi perubahan logika pada pin tersebut yang secara otomatis memicu interrupt. STM32 kemudian menjalankan fungsi callback khusus (HAL_GPIO_EXTI_Callback) yang langsung mengeksekusi aksi tertentu, yaitu menyalakan atau mematikan motor DC dan menghentikan pergerakan stepper motor saat sensor aktif. Penggunaan interrupt eksternal ini memungkinkan respon yang cepat dan efisien tanpa perlu memantau status sensor secara terus-menerus di dalam loop utama, sehingga sistem tetap hemat resource dan responsif terhadap perubahan input dari sensor.
Pada percobaan dengan Raspberry Pi Pico yang menggunakan komponen motor servo, buzzer, potensiometer, dan sensor DHT22, metode yang digunakan untuk mendeteksi input dari sensor atau tombol adalah dengan teknik polling, bukan interrupt eksternal. Potensiometer yang terhubung ke ADC (GPIO 26) dibaca secara berkala di dalam loop utama untuk mengontrol sudut motor servo. Begitu juga dengan sensor DHT22 yang membaca suhu dan kelembapan secara rutin di dalam loop menggunakan perintah measure(). Hasil pembacaan sensor ini kemudian menentukan apakah buzzer akan berbunyi dengan melodi tertentu, sesuai dengan kondisi suhu dan kelembapan yang terdeteksi. Dalam program ini tidak ditemukan penggunaan interrupt eksternal, karena tidak ada konfigurasi interrupt seperti irq() atau callback yang biasanya digunakan untuk menangani perubahan status input secara otomatis. Semua input direspons secara berkala melalui pengecekan terus-menerus di loop utama. Hal ini cukup wajar karena baik potensiometer maupun DHT22 memang lebih cocok dibaca dengan polling, dan tidak memerlukan reaksi seketika yang mendesak seperti pada kasus tombol darurat atau sensor sentuh. Dengan demikian, interrupt eksternal belum diterapkan dalam percobaan ini karena seluruh sistem berjalan dengan pemantauan rutin melalui loop utama.
4. Analisa bagaimana cara kerja fungsi HAL_GetTick() pada STM32 dan utime.ticks_ms() pada Raspberry Pi Pico dalam menghitung waktu sejak sistem dinyalakan
Jawab:
Pada percobaan yang dilakukan, HAL_GetTick() pada STM32 dan utime.ticks_ms() pada Raspberry Pi Pico memiliki fungsi yang serupa, yaitu untuk menghitung waktu yang telah berlalu sejak sistem dinyalakan dalam satuan milidetik.
Fungsi HAL_GetTick() adalah bagian dari HAL (Hardware Abstraction Layer) yang disediakan oleh STM32. Fungsi ini mengembalikan jumlah milidetik yang telah berlalu sejak sistem dinyalakan (dalam hal ini sejak HAL_Init() dipanggil). Ini didasarkan pada SysTick timer yang sudah terkonfigurasi oleh sistem untuk menghasilkan interrupt dengan periode tetap (biasanya setiap 1 ms). Ketika interrupt terjadi, HAL_GetTick() menginkrementasi nilai internal untuk mencatat berapa lama sistem telah berjalan. Fungsi ini digunakan untuk mengukur waktu dalam STM32 dengan presisi tinggi seperti pengaturan delay atau penghitungan interval waktu.
Fungsi utime.ticks_ms() pada Raspberry Pi Pico adalah bagian dari pustaka utime yang digunakan untuk menangani waktu di platform tersebut. Fungsi ini mengembalikan jumlah milidetik yang telah berlalu sejak sistem di-reboot. Fungsi ini bekerja dengan cara memanfaatkan timer internal yang menginkrementasi waktu secara berkala. utime.ticks_ms() juga mengembalikan nilai dalam milidetik yang dapat digunakan untuk menghitung waktu atau untuk keperluan delay, serupa dengan HAL_GetTick() pada STM32, namun dengan API yang lebih sederhana.
Kedua fungsi tersebut memiliki tujuan yang sama, yaitu mengukur waktu yang telah berlalu sejak sistem dinyalakan, tetapi STM32 dengan HAL_GetTick() lebih dioptimalkan untuk aplikasi waktu real-time dan presisi tinggi, sementara utime.ticks_ms() pada Raspberry Pi Pico lebih cocok untuk aplikasi dengan kebutuhan waktu yang tidak terlalu ketat, meskipun tetap efektif dalam banyak aplikasi dasar.
5. Analisa bagaimana perbedaan konfigurasi dan kontrol pin PWM serta pemanfaatan timer internal pada STM32 dan Raspberry Pi Pico dalam menghasilkan sinyal gelombang persegi.
Jawab:
Pada percobaan yang dilakukan, STM32 dan Raspberry Pi Pico menggunakan PWM (Pulse Width Modulation) untuk menghasilkan sinyal gelombang persegi dengan cara yang berbeda, baik dalam hal konfigurasi pin maupun pemanfaatan timer internal. Berikut adalah analisis berdasarkan percobaan yang dilakukan:
a. STM32
Pada STM32, konfigurasi PWM dilakukan dengan memanfaatkan timer internal dan pin GPIO yang dikonfigurasi untuk fungsi PWM. Proses ini dimulai dengan mengonfigurasi pin GPIO dalam mode output alternatif (Alternate Function), yang kemudian dihubungkan ke timer internal. PWM dihasilkan dengan mengatur duty cycle dan frekuensi melalui register timer yang bersangkutan. Timer ini mengontrol siklus kerja sinyal PWM dan menghasilkan sinyal gelombang persegi.
Konfigurasi Pin PWM: Pin yang digunakan untuk PWM pada STM32 dikonfigurasi dalam mode output alternatif dan terkait dengan timer yang spesifik. Dalam kode STM32, hal ini dilakukan dengan mengonfigurasi pin menggunakan GPIO_Init() dan menentukan fungsi timer melalui HAL_TIM_PWM_Start().
Pemanfaatan Timer Internal: STM32 memiliki beberapa timer dengan presisi yang tinggi, memungkinkan kontrol yang lebih akurat terhadap frekuensi dan duty cycle sinyal PWM. Timer ini akan menghasilkan sinyal PWM yang stabil dan dapat dikendalikan dengan presisi tinggi. Misalnya, untuk mengubah frekuensi PWM atau duty cycle, kita hanya perlu memodifikasi register timer yang sesuai.
b. Raspberry Pi Pico
Pada Raspberry Pi Pico, sinyal PWM dihasilkan menggunakan timer internal yang dikendalikan melalui Python. Pin GPIO dapat dikonfigurasi untuk menghasilkan PWM dengan menggunakan pustaka machine.PWM(), yang mengatur frekuensi dan duty cycle sinyal PWM.
Konfigurasi Pin PWM: Pada Raspberry Pi Pico, pin GPIO dapat dengan mudah dikonfigurasi untuk menghasilkan PWM menggunakan PWM() dari pustaka machine. Pin yang digunakan cukup ditentukan dalam fungsi Pin(), dan kontrol atas duty cycle dilakukan dengan memodifikasi nilai duty cycle melalui duty_u16().
Pemanfaatan Timer Internal: Raspberry Pi Pico menggunakan timer internal untuk menghasilkan PWM. Meskipun kontrolnya lebih sederhana dibandingkan STM32, Pico mampu menghasilkan sinyal PWM dengan frekuensi dan duty cycle yang dapat diatur dengan menggunakan fungsi seperti freq() untuk frekuensi dan duty_u16() untuk duty cycle. Namun, meskipun cukup efektif untuk aplikasi sederhana, timer internal pada Pico memiliki keterbatasan jika dibandingkan dengan STM32 dalam hal presisi waktu.
Perbedaan Utama
- Kontrol Pin: Pada STM32, konfigurasi pin PWM lebih rumit karena melibatkan pengaturan mode alternatif untuk pin dan penggunaan register timer yang lebih detail. Di sisi lain, Raspberry Pi Pico menggunakan pustaka yang lebih sederhana seperti machine.PWM() untuk mengontrol pin GPIO sebagai PWM.
- Pemanfaatan Timer Internal: STM32 memiliki kemampuan timer yang lebih canggih dengan lebih banyak fitur dan kontrol lebih presisi terhadap frekuensi dan duty cycle. Raspberry Pi Pico menggunakan timer internal yang cukup sederhana, cocok untuk aplikasi yang tidak memerlukan presisi waktu yang sangat tinggi.
- Presisi: STM32 memiliki presisi lebih tinggi dalam kontrol frekuensi PWM berkat timer dengan resolusi tinggi, yang sangat ideal untuk aplikasi yang membutuhkan sinkronisasi atau pengaturan waktu yang lebih akurat. Raspberry Pi Pico cukup untuk aplikasi yang lebih sederhana, tetapi keterbatasan presisinya dapat mempengaruhi aplikasi yang lebih kompleks.
Secara keseluruhan, STM32 memberikan lebih banyak fleksibilitas dan presisi dalam hal kontrol PWM dan penggunaan timer internal, sementara Raspberry Pi Pico lebih mudah diatur untuk aplikasi yang tidak membutuhkan kontrol presisi yang sangat tinggi.
SOAL TAMBAHAN
1. Kenapa saat percobaan 8 tidak bisa di lakukan?
Jawab:
Pada percobaan 8, simulasi tidak dapat dilakukan dengan STM32, hal dikarenakan
a. Konfigurasi Software atau driver Tidak Tepat
Pengaturan software untuk debugger (ST-Link) dan perangkat lunak pengembang (seperti STM32CubeIDE) mungkin tidak sesuai, menyebabkan STM32 tidak dapat terdeteksi atau diprogram. Pastikan driver ST-Link sudah terinstal dengan benar, dan perangkat lunak (seperti STM32CubeIDE atau STM32CubeProgrammer) bisa mendeteksi ST-Link.
b. Koneksi Hardware Tidak Stabil
Kabel atau konektor antara ST-Link dan STM32 mungkin tidak terpasang dengan baik atau ada masalah pada koneksi pin yang menghambat komunikasi. Periksa kabel dan konektor untuk memastikan koneksi yang stabil dan tidak ada kerusakan pada kabel.
c. Pengaturan Power
Pastikan STM32 mendapatkan daya yang cukup dan stabil. Jika tegangan tidak sesuai, STM32 mungkin tidak dapat berfungsi dengan baik.
d. Kesalahan di Mode Boot STM32
STM32 terjebak dalam mode boot yang salah, sehingga ST-Link tidak dapat mengakses mikrokontroler untuk pemrograman.
Maka, dengan memperbaiki konfigurasi software, memeriksa koneksi hardware, memastikan kestabilan daya, dan mengecek mode boot STM32, percobaan dapat dilakukan dengan lancar.
2. kenapa percobaan 8 untuk penggunaan motor dc menggunakan transistor?
Jawab:
Pada percobaan 8, transistor digunakan dalam rangkaian motor DC untuk beberapa alasan, seperti transistor digunakan sebagai saklar untuk mengendalikan kapan motor DC menyala atau mati, terutama jika sumber daya motor berbeda dengan mikrokontroler. Selain itu, transistor juga memperkuat sinyal kontrol yang berasal dari mikrokontroler, mengingat mikrokontroler biasanya menghasilkan sinyal dengan arus kecil. Dengan demikian, transistor memperkuat sinyal tersebut agar motor dapat beroperasi dengan baik.
Selain itu, bisa diketahui Pada rangkaian PWM (Pulse Width Modulation) untuk kontrol kecepatan motor terdapat adanya transistor. Transistor tersebut berperan dalam mengatur kecepatan motor dengan mengubah durasi sinyal yang dikirimkan ke motor. Transistor juga digunakan sebagai pelindung komponen lainnya, karena motor DC memiliki kumparan yang bisa menghasilkan tegangan balik (back EMF) yang dapat merusak rangkaian kontrol utama. Transistor berfungsi untuk membatasi back EMF tersebut, menjaga agar tidak masuk ke rangkaian kontrol dan melindungi komponen-komponen lainnya.
3. kenapa pin 15 diganti dengan pin 1 pada percobaan 5?
Jawab:
Pada percobaan 5, Pin 15 merupakan salah satu pin GPIO yang bisa diprogram untuk berbagai fungsi, namun tidak semua pin pada Raspberry Pi Pico memiliki kemampuan PWM yang sama. Pin 15 ini pada Raspberry Pi Pico tidak dapat digunakan secara langsung untuk PWM karena tidak mendukung hardware PWM. Pin ini lebih terbatas dalam fungsinya untuk aplikasi yang membutuhkan kontrol sinyal yang lebih presisi, seperti pengendalian motor atau servo, berbeda dengan pin 1. Pin 1 dipilih karena mendukung fitur PWM dengan kontrol yang lebih tepat dan lebih mudah digunakan untuk aplikasi yang memerlukan pengendalian motor atau servo dengan sinyal PWM yang stabil. Sehingga, pin 1 lebih cocok untuk aplikasi yang membutuhkan kualitas sinyal PWM yang lebih baik dan kompatibilitas yang lebih luas.
Video Rangkaian Praktikum[tekan disini]
HTML [tekan disini]
Program STM32CubeIDE [tekan disini]
[menuju awal]
Komentar
Posting Komentar