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 Breadboard2. Konfigurasi Pin pada STM32CubeIDEMotor 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 STM32CubeIDEBuat 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 STM32CubeIDETulis kode untuk kontrol motor DC menggunakan PWM, kontrol stepper, dan pembacaan sensor touch. Gunakan ADC untuk membaca nilai dari potentiometer.5. Hubungkan STM32 ke LaptopSambungkan STM32 ke laptop menggunakan ST-Link. Pastikan ST-Link terdeteksi di STM32CubeIDE.6. Build dan Run ProgramBuild proyek dan upload ke STM32 melalui ST-Link. Jalankan program dan verifikasi kontrol motor dan stepper sesuai dengan input sensor touch.7. Verifikasi dan PengujianPastikan motor DC dan stepper motor berfungsi sesuai dengan input yang diterima dari sensor touch dan potentiometer.
.jpeg)
.jpeg)
.jpeg)
#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) {}
}
Pada STM32, PWM (Pulse Width Modulation) diimplementasikan menggunakan timer internal yang dikonfigurasi melalui HAL Library. Setiap timer memiliki beberapa channel yang dapat digunakan untuk menghasilkan sinyal PWM, dengan pengaturan prescaler dan period yang menentukan frekuensi dan resolusi sinyal. Pendekatan ini memungkinkan kontrol PWM yang sangat presisi, baik untuk aplikasi motor maupun LED.
Sementara itu, pada Raspberry Pi Pico, PWM dapat diakses melalui pustaka MicroPython (machine.PWM) atau melalui C SDK. PWM Pico juga menggunakan timer internal, tetapi pengaturannya lebih sederhana, meskipun tetap mendukung resolusi hingga 16-bit. Namun, sinkronisasi antar pin PWM pada Pico cenderung lebih sulit dibandingkan STM32, yang bisa menyinkronkan beberapa channel pada satu timer.
Dari sisi dampak, STM32 memberikan kontrol yang lebih halus dan presisi terhadap kecepatan motor atau kecerahan LED, terutama pada aplikasi yang membutuhkan waktu siklus yang sangat stabil. Pico cukup efektif untuk penggunaan umum, tetapi bisa terbatas untuk aplikasi industri presisi tinggi.
2.Analisa bagaimana cara pembacaan nilai sensor analog menggunakan ADC pada STM32 dan Raspberry Pi Pico
jawab:
STM32 menggunakan ADC (Analog-to-Digital Converter) internal yang dapat diakses melalui fungsi HAL seperti HAL_ADC_Start(), HAL_ADC_PollForConversion(), dan HAL_ADC_GetValue(). ADC pada STM32 biasanya memiliki resolusi 12-bit, dan dapat bekerja dalam mode polling, interrupt, atau DMA, memungkinkan pengambilan data sensor secara efisien dan terus-menerus.
Pada Raspberry Pi Pico, pembacaan ADC dilakukan melalui pin analog yang tersedia, dengan menggunakan pustaka machine.ADC pada MicroPython. ADC Pico juga memiliki resolusi 12-bit, tetapi pembacaannya umumnya dilakukan dengan cara polling, tanpa dukungan DMA secara langsung di MicroPython.
Kelebihan STM32 terletak pada fleksibilitas mode pembacaan dan kemampuannya menangani data dalam jumlah besar dengan efisiensi tinggi, sementara Pico lebih cocok untuk aplikasi sederhana dengan frekuensi pembacaan yang tidak terlalu tinggi.
3.Analisa bagaimana penggunaan interrupt eksternal dalam mendeteksi input dari sensor atau tombo pada STM32 dan Raspberry Pi Pico.
jawab:
STM32 mendukung penggunaan interrupt eksternal yang sangat fleksibel melalui fungsi HAL_GPIO_EXTI_Callback() dan konfigurasi NVIC. Pin dapat dikonfigurasi untuk memicu interrupt pada rising edge, falling edge, atau keduanya. Ini memungkinkan deteksi perubahan input (seperti tombol atau sensor digital) secara real-time tanpa harus terus-menerus melakukan polling.
Pada Raspberry Pi Pico dengan MicroPython, interrupt dapat diatur menggunakan fungsi irq() dari objek pin, yang juga dapat dikonfigurasi untuk rising atau falling edge. Namun, penanganan interrupt di MicroPython memiliki latensi lebih tinggi dan terbatas kemampuannya dibandingkan implementasi di level C atau STM32.
Dengan demikian, STM32 lebih unggul untuk aplikasi yang sangat bergantung pada respons cepat terhadap perubahan input, seperti deteksi pulsa encoder atau sinyal sensor digital berkecepatan tinggi.
4.
4. Cara Kerja HAL_GetTick() pada STM32 dan utime.ticks_ms() pada Raspberry Pi Pico
Fungsi HAL_GetTick() pada STM32 menggunakan timer sistem (SysTick) yang menghasilkan interrupt setiap 1 ms. Nilai waktu ini disimpan dalam variabel global dan diinkrementasi setiap milidetik oleh interrupt handler. Oleh karena itu, HAL_GetTick() memberikan nilai waktu sejak sistem dinyalakan dalam satuan milidetik dan sangat andal untuk melakukan delay atau pengukuran waktu relatif.
Sebaliknya, utime.ticks_ms() pada Raspberry Pi Pico juga mengembalikan waktu dalam milidetik sejak board dinyalakan, menggunakan sistem waktu internal. Namun, dalam MicroPython, ada batasan overflow nilai (biasanya 30 bit), sehingga perlu hati-hati saat menghitung selisih waktu menggunakan utime.ticks_diff().
Secara umum, kedua fungsi bekerja dengan prinsip yang serupa, tetapi STM32 lebih akurat untuk aplikasi real-time karena kestabilan clock dan integrasi erat dengan sistem interrupt-nya.
5. Perbedaan Konfigurasi dan Kontrol Pin PWM serta Pemanfaatan Timer Internal dalam Menghasilkan Sinyal Gelombang Persegi
Pada STM32, konfigurasi pin PWM sangat bergantung pada pemetaan pin terhadap timer internal (misalnya TIM1, TIM2, dll.). HAL Library menyediakan API yang memungkinkan pengguna mengatur frekuensi dan duty cycle dengan sangat spesifik. Timer di STM32 memiliki banyak fitur seperti auto-reload, prescaler, dan mode output compare, yang bisa digunakan untuk menghasilkan gelombang persegi dengan presisi tinggi dan sinkronisasi antar channel.
Di Raspberry Pi Pico, PWM disediakan oleh delapan slice PWM, masing-masing dengan dua channel. Setiap pin PWM dipetakan ke salah satu slice, dan konfigurasi dilakukan melalui fungsi PWM dalam MicroPython atau SDK di C. Pico memungkinkan pengaturan frekuensi dan duty cycle, tetapi tidak semudah STM32 dalam hal sinkronisasi antar pin atau manipulasi tingkat lanjut dari timer.
Secara keseluruhan, STM32 lebih unggul dalam pengendalian presisi sinyal gelombang persegi, terutama pada sistem tertanam yang kompleks dan kritis terhadap waktu. Pico tetap efektif, tetapi lebih cocok untuk prototipe dan aplikasi edukatif.
Tidak ada komentar:
Posting Komentar