LA1 Modul 2 up&uc

[menuju akhir]

Laporan Akhir 1 Modul 2

(Percobaan 8)

1. Prosedur[kembali]

  1. Menentukan Komponen yang Digunakan

    • Komponen yang digunakan dalam percobaan ini adalah 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

    • Tentukan pin GPIO untuk PWM motor DC.

    • Tentukan pin GPIO untuk kontrol Stepper Motor (IN1, IN2, IN3, IN4).

    • Tentukan pin GPIO untuk input Sensor Touch.

    • Tentukan pin ADC untuk pembacaan nilai dari Potentiometer.

    • Tentukan pin GPIO untuk mengontrol Transistor.

  3. Setup di STM32CubeIDE

    • Buat proyek baru di STM32CubeIDE dan pilih STM32 model yang sesuai dengan board yang digunakan.

    • Atur konfigurasi pin GPIO untuk motor, stepper, sensor touch, dan potentiometer sesuai dengan fungsinya (output untuk motor dan stepper, input/analog untuk sensor touch dan potentiometer).

  4. Program di STM32CubeIDE

    • Tulis kode untuk mengontrol motor DC menggunakan PWM, kontrol stepper motor, dan pembacaan sensor touch.

    • Gunakan ADC untuk membaca nilai dari potensiometer dan sesuaikan dengan kebutuhan kontrol motor atau stepper.

  5. Build dan Run Program

    • Sambungkan STM32 ke laptop menggunakan ST-Link dan pastikan terdeteksi di STM32CubeIDE.

    • Build proyek dan upload program ke STM32 melalui ST-Link.

    • Jalankan program dan lakukan verifikasi untuk memastikan motor DC dan stepper berfungsi sesuai input yang diterima dari sensor touch dan potensiometer.

2. Hardware dan Diagram Blok[kembali]

1) White Board atau Project Board
2) STM 32

3) Motor Servo

4) Resistor 
5) Jumper
6) Sensor Touch

7) Potensiometer

8) Transistor

9) Stepper


b. Blok Diagram

3. Rangkaian Simulasi dan Prinsip Kerja[kembali]

Prinsip Kerja Percobaan:

  1. Pengendalian Motor Berdasarkan Input Sensor Touch dan Potentiometer

    • Sensor touch terhubung ke pin PB0 pada STM32 sebagai input digital. Ketika sensor tidak disentuh (logika low), STM32 membaca nilai analog dari potentiometer melalui ADC pada pin PA0.

  2. Kontrol Stepper Motor dengan Potentiometer

    • Nilai ADC yang dibaca dari potentiometer digunakan untuk mengendalikan arah putaran stepper motor.

    • Jika nilai ADC < 2048, stepper berputar searah jarum jam (CW).

    • Jika nilai ADC ≥ 2048, stepper berputar berlawanan arah jarum jam (CCW).

    • Stepper dikontrol menggunakan 4 pin output (PB8–PB11), yang diatur secara bergantian untuk menghasilkan gerakan.

  3. Kontrol Motor DC dengan Sensor Touch dan Interupsi

    • Ketika 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).

    • Sistem memastikan hanya satu motor yang aktif pada satu waktu: jika sensor tidak disentuh, stepper motor berputar sesuai nilai potentiometer; jika sensor disentuh, motor DC menyala dan stepper berhenti.

  4. Peran Transistor pada Motor DC

    • Transistor yang terhubung ke motor DC berfungsi untuk memperkuat arus PWM yang dihasilkan oleh mikrokontroler, sehingga motor DC dapat beroperasi dengan aman dan efisien.

  5. Sistem Kerja Loop dan Pemantauan

    • Seluruh sistem bekerja dalam sebuah loop di fungsi main(), dengan terus memantau kondisi sensor dan pembacaan nilai dari potentiometer untuk kontrol dinamis terhadap motor.

Kesimpulan:

Percobaan ini menunjukkan bagaimana STM32 dapat digunakan untuk mengendalikan dua jenis motor (stepper dan DC) berdasarkan input dari sensor touch dan potentiometer. Penggunaan interupsi dan ADC memungkinkan kontrol yang efisien dan responsif, sementara transistor berfungsi untuk meningkatkan arus PWM agar motor DC dapat beroperasi dengan aman. Sistem ini mengilustrasikan penerapan teknik kontrol motor dengan input digital dan analog secara bersamaan.

4. Flowchart dan Listing Program [kembali]

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: Clockwise (CW) dan Counter-Clockwise (CCW)

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; // Status sentuhan


// Fungsi prototipe

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)

{

// Jika sensor tidak disentuh, jalankan stepper

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; // Mode berdasarkan ADC

}


if (current_mode == 0)

RunStepper(STEP_SEQ_CW, 5);

else

RunStepper(STEP_SEQ_CCW, 5);

}


HAL_Delay(1);

}

}


// Fungsi untuk menjalankan motor stepper 1 langkah

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);

}


// Inisialisasi GPIO

void MX_GPIO_Init(void)

{

GPIO_InitTypeDef GPIO_InitStruct = {0};


__HAL_RCC_GPIOB_CLK_ENABLE();

__HAL_AFIO_REMAP_SWJ_NOJTAG(); // Nonaktifkan JTAG jika perlu PB3-PB4


// Touch Sensor - Input dengan interrupt (EXTI)

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);


HAL_NVIC_SetPriority(EXTI0_IRQn, 0, 0);

HAL_NVIC_EnableIRQ(EXTI0_IRQn);


// Motor DC - Output push-pull

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);


// Stepper Motor - Output push-pull

GPIO_InitStruct.Pin = IN1_PIN | IN2_PIN | IN3_PIN | IN4_PIN;

HAL_GPIO_Init(STEPPER_PORT, &GPIO_InitStruct);

}


// Inisialisasi ADC

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();

}


// Konfigurasi 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;


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();

}


// Callback ketika EXTI dipicu oleh sensor sentuh

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)

{

// Saat disentuh: 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

{

// Saat dilepas: matikan motor DC

HAL_GPIO_WritePin(MOTOR_DC_PORT, MOTOR_DC_PIN, GPIO_PIN_RESET);

}

}

}


// Handler untuk EXTI line 0

void EXTI0_IRQHandler(void)

{

HAL_GPIO_EXTI_IRQHandler(TOUCH_SENSOR_PIN);

}


// Handler untuk error

void Error_Handler(void)

{

while (1)

{

// Bisa ditambahkan indikator LED jika diperlukan

}

}


5. Analisa [kembali]

1. Analisa bagaimana perbedaan implementasi PWM antara STM32 dan Raspberry Pi Pico serta dampaknya terhadap kontrol motor dan LED.

jawab :

Pada percobaan yang dilakukan, implementasi PWM pada STM32 dan Raspberry Pi Pico menunjukkan perbedaan mencolok dalam hal presisi dan kemampuan kendali perangkat. STM32, yang digunakan untuk mengontrol motor DC dan stepper berdasarkan input dari sensor touch dan potensiometer, memanfaatkan PWM berbasis hardware timer yang memungkinkan pengaturan kecepatan motor secara halus dan responsif terhadap perubahan input, seperti saat motor stepper dimatikan dan motor DC diaktifkan ketika sensor disentuh. Sementara itu, Raspberry Pi Pico yang diprogram menggunakan Thonny IDE digunakan untuk membaca data dari sensor DHT22 dan potensiometer, lalu menghasilkan sinyal PWM untuk mengontrol buzzer dan motor servo. PWM pada Pico digunakan untuk mengatur nada buzzer berdasarkan kondisi suhu dan kelembapan, serta menggerakkan motor servo, namun karena PWM Pico bersifat software dan terbatas dalam presisi, responsnya tidak seakurat STM32, terutama saat harus menjalankan beberapa fungsi sekaligus. Hal ini tentu saja membuat perbedaan respon pwm pada stm 32 dan respberry pi pico

2. Analisa bagaimana cara pembacaan nilai sensor analog menggunakan ADC pada STM32 dan Raspberry Pi Pico

jawab:

Pada percobaan yang dilakukan, pembacaan nilai sensor analog menggunakan ADC pada STM32 dan Raspberry Pi Pico menunjukkan perbedaan dalam kecepatan dan presisi. STM32 menggunakan ADC 12-bit yang mampu membaca sinyal analog dengan cepat dan akurat, serta mendukung fitur seperti DMA untuk mengakses data secara efisien tanpa membebani prosesor utama. Ini memungkinkan pembacaan sensor yang lebih responsif, seperti pada sensor touch yang mengendalikan motor DC dan stepper. Di sisi lain, Raspberry Pi Pico juga menggunakan ADC 12-bit, namun dengan jumlah pin ADC terbatas (hanya tiga pin ADC), sehingga pembacaan sensor dilakukan secara bergantian, yang bisa memperlambat proses jika banyak sensor yang perlu dibaca. Meskipun ADC Pico cukup efektif untuk aplikasi sederhana, kecepatan dan presisi pembacaan sensor pada STM32 lebih unggul, dalam pengolahan data secara real-time 

3. Analisa bagaimana penggunaan interrupt eksternal dalam mendeteksi input dari sensor atau tombo pada STM32 dan Raspberry Pi Pico.

jawab:

Pada STM32, interrupt eksternal digunakan untuk mendeteksi perubahan input pada sensor atau tombol secara otomatis, memungkinkan respons cepat tanpa perlu memantau status sensor terus-menerus. Hal ini menghemat sumber daya dan mempercepat proses. Sementara itu, Raspberry Pi Pico menggunakan polling, di mana sistem secara berkala memeriksa status sensor dalam loop utama, yang kurang efisien karena tidak dapat merespons perubahan input secara otomatis. Jadi, STM32 lebih efektif untuk aplikasi yang membutuhkan respons cepat, sementara Pico lebih cocok untuk aplikasi yang tidak memerlukan reaksi langsung.

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:

Fungsi HAL_GetTick() pada STM32 dan utime.ticks_ms() pada Raspberry Pi Pico keduanya digunakan untuk mengukur waktu yang telah berlalu sejak sistem dinyalakan. HAL_GetTick() bekerja dengan mengandalkan timer internal (SysTick) yang diatur untuk menghasilkan interrupt setiap milidetik, mencatat waktu dalam bentuk milidetik. Sedangkan utime.ticks_ms() pada Raspberry Pi Pico menggunakan timer internal yang menginkrementasi waktu sejak reboot, juga dalam milidetik. Meskipun keduanya berfungsi serupa, HAL_GetTick() lebih presisi dan terintegrasi dalam sistem STM32, sementara utime.ticks_ms() lebih sederhana dan cocok untuk aplikasi dasar di Pico.

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 STM32, konfigurasi PWM dilakukan dengan mengatur pin GPIO dalam mode alternatif dan menghubungkannya ke timer internal yang memiliki presisi tinggi. Timer ini memungkinkan kontrol yang lebih akurat terhadap frekuensi dan duty cycle PWM, menghasilkan sinyal gelombang persegi yang stabil. Di sisi lain, Raspberry Pi Pico menggunakan pustaka Python (machine.PWM) untuk mengonfigurasi pin PWM, yang lebih sederhana namun terbatas dalam presisi. Timer internal di Pico dapat mengatur frekuensi dan duty cycle, namun kurang presisi jika dibandingkan dengan STM32 yang menggunakan hardware timer dengan lebih banyak fitur. Dengan demikian, STM32 menawarkan kontrol PWM yang lebih canggih dan presisi tinggi, sedangkan Pico lebih cocok untuk aplikasi sederhana dengan kontrol PWM yang lebih mudah diatur meskipun kurang presisi.


Soal tambahan 

1. kenapa percobaan 8 untuk penggunaan motor dc menggunakan transistor?

jawab:

Transistor diguanakan untuk melindungi komponen lain dari tegangan balik (back EMF) yang dihasilkan oleh motor DC, yang bisa merusak rangkaian kontrol. Dengan demikian, transistor bertindak sebagai pelindung, memastikan rangkaian kontrol tetap aman dari kerusakan akibat back EMF.

2. kenapa pin 15 diganti dengan pin 1 pada percobaan 5

jawab:

pin 15 dan pin 1 keduanya dapat digunakan untuk PWM, penggantian dilakukan untuk alasan kemudahan dalam pengelolaan kode dan pin 1 lebih sesuai dengan layout perangkat keras yang digunakan dalam percobaan tersebut.

6. Video Simulasi [kembali]



7. Download file [kembali]

Video Rangkaian Praktikum[Download]
Datasheet Resistor [Download]
Datasheet Motor servo [Download]
Datasheet STM32F103C8 [Download]














[menuju awal]

Tidak ada komentar:

Posting Komentar

Langganan: Postingan (Atom)

     BAHAN PRESENTASI     MATA KULIAH ELEKTRONIKA 2022 Oleh Zahara 2210953017 DOSEN PENGAMPU DR. DARWISON, M.T. Referensi  1. Darwison, 2010...

Postingan Populer