Sabtu, 09 Mei 2026

M3 : Tugas Pendahuluan 1


Soal :
  1. Jelaskan apa itu protocol UART, SPI, dan I2C?
  2. Bagaimana konfigurasi komunikasi UART pada STM 32 F103C8T6 dan STM NUCLEO G474RE pada hardware dan software?
  3. Bagaimana konfigurasi SPI pada STM 32 F103C8T6 dan STM NUCLEO G474RE pada hardware dan software?
  4. Bagaimana konfigurasi I2C pada STM 32 F103C8T6 dan STM NUCLEO G474RE pada hardware dan software?
  5. Jelaskan perbedaan UART, SPI, dan I2C!

Jawaban :

  
 
 
 
 

 

Modul 3: Communication

 


DAFTAR ISI

Percobaan ...
  1. A. Tugas Pendahuluan 1
  2. C. Laporan Akhir Percobaan 1
  3. D. Laporan Akhir Percobaan 2

MODUL 3

COMMUNICATION

1. Pendahuluan [kembali]

a) Asistensi dilakukan 1x

b) Praktikum dilakukan 1x


2. Tujuan [kembali]

a) Memahami cara penggunaan protokol komunikasi UART, SPI, dan I2C pada Development Board yang digunakan

b) Memahami cara penggunaan komponen input dan output yang berkomunikasi secara UART, SPI, dan I2C pada Development Board yang digunakan

3. Alat dan Bahan [kembali]

    a) STM32 NUCLEO G474RE

    b) STM32F103C8

    c) LDR Sensor




d) PIR Sensor


  

e) Push Button



    f) LED



    f) Fan



    g) OLED


    h) Resistor


    i) Jumper


    j) Adaptor

    k) Breadboard



4. Dasar Teori [kembali]

4.1 UART (Universal Asynchronous Receiver Transmitter)

UART (Universal Asynchronous Receiver-Transmitter) adalah bagian perangkat keras komputer yang menerjemahkan antara bit-bit paralel data dan bit-bit serial. UART biasanya berupa sirkuit terintegrasi yang digunakan untuk komunikasi serial pada komputer atau port serial perangkat periperal.

Cara Kerja Komunikasi UART

Gambar 1. Cara Kerja Komunikasi UART

4.2 I2C (Inter-Intergrated Circuit)

Inter Integrated Circuit atau sering disebut I2C adalah standar komunikasi serial dua arah menggunakan dua saluran yang didisain khusus untuk mengirim maupun menerima data. Sistem I2C terdiri dari saluran SCL (Serial Clock) dan SDA (Serial Data) yang membawa informasi data antara I2C dengan pengontrolnya.

Cara Kerja Komunikasi I2C

Gambar 2. Cara Kerja Komunikasi I2C

Pada I2C, data ditransfer dalam bentuk message yang terdiri dari kondisi start, Address Frame, R/W bit, ACK/NACK bit, Data Frame 1, Data Frame 2, dan kondisi Stop. Kondisi start dimana saat pada SDA beralih dari logika high ke low sebelum SCL. Kondisi stop dimana saat pada SDA beralih dari logika low ke high sebelum SCL.

R/W bit berfungsi untuk menentukan apakah master mengirim data ke slave atau meminta data dari slave. (logika 0 = mengirim data ke slave, logika 1 = meminta data dari slave) ACK/NACK bit berfungsi sebagai pemberi kabar jika data frame ataupun address frame telah diterima receiver.

4.3 SPI (Series Peripheral Interface)

Serial Peripheral Interface (SPI) merupakan salah satu mode komunikasi serial synchronous berkecepatan tinggi yang dimiliki oleh STM32F407VGT6 dan Raspberry Pi Pico. Komunikasi SPI membutuhkan 3 jalur utama yaitu MOSI, MISO, dan SCK, serta jalur tambahan SS/CS. Melalui komunikasi ini, data dapat saling dikirimkan baik antara mikrokontroler maupun antara mikrokontroler dengan perangkat periferal lainnya.

• MOSI (Master Output Slave Input)
Jika dikonfigurasi sebagai master, maka pin MOSI berfungsi sebagai output. Sebaliknya, jika dikonfigurasi sebagai slave, maka pin MOSI berfungsi sebagai input.

• MISO (Master Input Slave Output)
Jika dikonfigurasi sebagai master, maka pin MISO berfungsi sebagai input. Sebaliknya, jika dikonfigurasi sebagai slave, maka pin MISO berfungsi sebagai output.

• SCLK (Serial Clock)
Jika dikonfigurasi sebagai master, maka pin SCLK bertindak sebagai output untuk memberikan sinyal clock ke slave. Sebaliknya, jika dikonfigurasi sebagai slave, maka pin SCLK berfungsi sebagai input untuk menerima sinyal clock dari master.

• SS/CS (Slave Select/Chip Select)
Jalur ini digunakan oleh master untuk memilih slave yang akan dikomunikasikan. Pin SS/CS harus dalam keadaan aktif (umumnya logika rendah) agar komunikasi dengan slave dapat berlangsung.

Cara Kerja Komunikasi SPI

Gambar 3. Cara Kerja Komunikasi SPI

Sinyal clock dialirkan dari master ke slave yang berfungsi untuk sinkronisasi. Master dapat memilih slave mana yang akan dikirimkan data melalui slave select, kemudian data dikirimkan dari master ke slave melalui MOSI. Jika master butuh respon data maka slave akan mentransfer data ke master melalui MISO.

4.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:

Gambar 2. STM32 Nucleo G474RE

Gambar 3. PinOut STM32 Nucleo G474RE

4.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:

Gambar 4. STM32F103C8

Gambar 5. Pinout Stm32 F103C8T6


A. BAGIAN-BAGIAN PENDUKUNG

1.4.1 STM32 NUCLEOG474RE

  1. RAM (Random Access Memory)
    RAM (Random Access Memory) pada STM32 NUCLEO-G474RE digunakan sebagai memori sementara untuk menyimpan data selama program berjalan. Mikrokontroler STM32G474RET6 memiliki RAM sebesar 128 KB yang berfungsi untuk menyimpan variabel, buffer data, stack, dan heap.
  2. Memori Flash Eksternal STM32
    NUCLEO-G474RE tidak menggunakan memori flash eksternal. Seluruh program dan data permanen disimpan pada memori Flash internal mikrokontroler STM32G474RET6 dengan kapasitas 512 KB. Memori flash ini bersifat non-volatile, sehingga data dan program tetap tersimpan meskipun catu daya dimatikan.
  3. Crystal Oscillator
    STM32 NUCLEO-G474RE menggunakan osilator internal (HSI – High Speed Internal) sebagai sumber clock utama secara default. Penggunaan clock internal ini membuat board dapat beroperasi tanpa memerlukan crystal oscillator eksternal. Clock berfungsi sebagai sumber waktu untuk mengatur kecepatan kerja CPU dan seluruh peripheral.
  4. Regulator Tegangan
    Untuk memastikan pasokan tegangan yang stabil ke mikrokontroler.
  5. Pin GPIO (General Purpose Input/Output):
    Pin GPIO pada STM32 NUCLEO-G474RE digunakan sebagai antarmuka input dan output digital yang fleksibel.

1.4.2 STM32 F103C8

  1. RAM (Random Access Memory)
    STM32F103C8 dilengkapi dengan 20KB SRAM on-chip. Kapasitas RAM ini memungkinkan mikrokontroler menjalankan berbagai aplikasi serta menyimpan data sementara selama eksekusi program.
  2. Memori Flash Internal
    STM32F103C8 memiliki memori flash internal sebesar 64KB atau 128KB, yang digunakan untuk menyimpan firmware dan program pengguna. Memori ini memungkinkan penyimpanan kode program secara permanen tanpa memerlukan media penyimpanan eksternal.
  3. Crystal Oscillator
    STM32F103C8 menggunakan crystal oscillator eksternal (biasanya 8MHz) yang bekerja dengan PLL untuk meningkatkan frekuensi clock hingga 72MHz. Sinyal clock yang stabil ini penting untuk mengatur kecepatan operasi mikrokontroler dan komponen lainnya.
  4. Regulator Tegangan
    STM32F103C8 memiliki sistem pengaturan tegangan internal yang memastikan pasokan daya stabil ke mikrokontroler. Tegangan operasi yang didukung berkisar antara 2.0V hingga 3.6V.
  5. Pin GPIO (General Purpose Input/Output)
    STM32F103C8 memiliki hingga 37 pin GPIO yang dapat digunakan untuk menghubungkan berbagai perangkat eksternal seperti sensor, motor, LED, serta komunikasi dengan antarmuka seperti UART, SPI, dan I²C.

Kamis, 30 April 2026

Laporan Akhir 2 Modul 2

 

[KEMBALI KE MENU SEBELUMNYA] 



Laporan Akhir 2
Sistem Lampu Jalan Otomatis

1. Prosedur 
[Kembali]

1. Rangkai rangkaian di proteus sesuai dengan kondisi percobaan.
2. Buat program untuk mikrokontroler STM32 Nucleo G474RE di software STM32 CubeIDE.
3. Compile program dalam format hex, lalu upload ke dalam mikrokontroler.
4. Setelah program selesai di upload, jalankan simulasi rangkaian pada proteus.
5. Selesai.


Hardware :

a) Mikrokontroler STM32 Nucleo G474RE



2. LED







3. PIR Sensor






4. Power Supply

 
5.Push Button



6. Breadboard





7. Adaptor


8. Resistor


9. Jumper





Diagram Blok  :








Rangkaian Simulasi
 







Prinsip Kerja : 


Prinsip kerja rangkaian ini dimulai dari pembacaan intensitas cahaya lingkungan oleh LDR melalui ADC. Apabila nilai yang terbaca menunjukkan kondisi terang (siang hari), maka LED akan dimatikan. Sebaliknya, jika terdeteksi kondisi gelap (malam hari), sistem akan mengaktifkan sensor PIR untuk mendeteksi adanya pergerakan. Ketika gerakan terdeteksi, LED menyala terang dengan nilai PWM LED_FULL. Jika tidak ada gerakan dalam selang waktu tertentu, LED tetap menyala namun dalam kondisi redup menggunakan nilai LED_DIM.


Push button difungsikan sebagai interrupt untuk mengubah status mode darurat melalui variabel emergency_mode. Saat mode darurat aktif, LED akan langsung dimatikan dan sistem tidak melakukan pembacaan baik dari LDR maupun PIR. Pengaturan tingkat kecerahan LED dilakukan menggunakan PWM dari TIM3, sehingga lampu dapat beroperasi dalam kondisi mati, redup, atau terang sesuai dengan kondisi cahaya sekitar dan hasil deteksi gerakan.




Flowchart :







Listing Program :
a. 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);
 }
}
b. 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
// LED PWM
#define LED_PORT GPIOA
#define LED_PIN GPIO_PIN_6

// PB1

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





1.Analisa bagaimana perbedaan implementasi PWM antara STM32 serta dampaknya terhadap kontrol motor dan LED!
Jawab: PWM pada STM32 dihasilkan oleh timer (misalnya TIM3) dengan mengatur nilai duty cycle melalui register compare. Perubahan duty cycle mempengaruhi lebar pulsa, sehingga:
pada LED → mengatur tingkat kecerahan
pada motor/servo → mengatur posisi atau kecepatan
Semakin besar duty cycle, semakin besar energi yang diberikan ke beban.

2.Analisa bagaimana cara pembacaan nilai sensor analog menggunakan ADC pada STM32!
Jawab: ADC membaca sinyal analog (0–3.3V) lalu mengubahnya menjadi data digital 12-bit (0–4095). Prosesnya:
konfigurasi channel ADC
start konversi (HAL_ADC_Start)
tunggu selesai (HAL_ADC_PollForConversion)
ambil data (HAL_ADC_GetValue)
Nilai ini kemudian digunakan untuk pengambilan keputusan (misalnya threshold LDR).

3.Analisa bagaimana penggunaan interrupt eksternal dalam mendeteksi input dari sensor atau tombol pada STM32!
Jawab: Interrupt eksternal digunakan untuk mendeteksi perubahan input (misalnya tombol) secara langsung tanpa polling. Saat terjadi trigger (falling/rising edge), STM32 menjalankan fungsi callback seperti: 
HAL_GPIO_EXTI_Callback()
Keuntungannya adalah respon cepat dan efisien karena tidak perlu pengecekan terus-menerus di loop.

4.Analisa bagaimana cara kerja fungsi HAL_GetTick() pada STM32!
Jawab: HAL_GetTick() mengembalikan waktu dalam satuan milidetik sejak sistem mulai berjalan. Fungsi ini berbasis timer SysTick dan digunakan untuk:
pengukuran waktu (interval)
delay non-blocking
Contohnya untuk menghitung selang waktu detak atau timeout.

5.Analisa bagaimana perbedaan konfigurasi dan kontrol pin PWM serta pemanfaatan timer internal pada STM32 dalam menghasilkan sinyal PWM!
Jawab: PWM dikonfigurasi dengan:
Prescaler → mengatur resolusi waktu
Period (ARR) → menentukan frekuensi PWM
Compare (CCR) → menentukan duty cycle

Timer internal menghasilkan sinyal periodik, dan perubahan nilai CCR mengubah lebar pulsa tanpa mengubah frekuensi.

6.Bagaimana mengatur pergerakan motor servo pada stm 32?
Jawab: Servo dikontrol dengan PWM frekuensi 50 Hz (periode 20 ms). Posisi ditentukan oleh lebar pulsa:
~1 ms → posisi minimum
~1.5 ms → posisi tengah
~2 ms → posisi maksimum

Di STM32 diatur dengan:
__HAL_TIM_SET_COMPARE()
Perubahan nilai compare mengubah sudut servo (misalnya 1200–1800 µs).







   Rangkaian dan Program Wokwi [tekan disini]

    Video Rangkaian [tekan disini]

    HTML [tekan disini]


Laporan Akhir 1 Modul 2

 

[KEMBALI KE MENU SEBELUMNYA] 



Laporan Akhir 1
Sistem Kontrol Suhu Ruangan

1. Prosedur 
[Kembali]

1. Rangkai rangkaian di proteus sesuai dengan kondisi percobaan.
2. Buat program untuk mikrokontroler STM32F103C8 di software STM32 CubeIDE.
3. Compile program dalam format hex, lalu upload ke dalam mikrokontroler.
4. Setelah program selesai di upload, jalankan simulasi rangkaian pada proteus.
5. Selesai.


Hardware :

a) Mikrokontroler STM32F103C8
STM32F103C8 board – Microscale





2. LM35 Sensor





3. Kipas DC








4. Power Supply

 
5.Push Button


6. Motor Driver l298N






7. Breadboard





8. Adaptor


9. Resistor






Diagram Blok  :




Rangkaian Simulasi
 





Prinsip Kerja : 

Prinsip kerja rangkaian ini adalah sensor suhu LM35 membaca suhu ruangan dalam bentuk tegangan analog, kemudian STM32 mengubah nilai analog tersebut menjadi data digital melalui ADC. Nilai ADC dikonversi menjadi tegangan dengan acuan 3,3 V, lalu dihitung menjadi suhu dalam derajat Celsius. Jika suhu berada di bawah 27°C, kipas dimatikan. Jika suhu mencapai 27°C atau lebih, mikrokontroler mengaktifkan arah putaran motor melalui pin GPIO dan mengatur kecepatan kipas menggunakan sinyal PWM dari TIM1.

Pada sistem ini, push button digunakan sebagai interrupt untuk mengaktifkan atau menonaktifkan sistem melalui variabel system_on. Saat sistem aktif, kipas bekerja berdasarkan suhu yang terbaca: pada suhu 27°C sampai 35°C duty cycle PWM berubah sesuai perhitungan program, sedangkan pada suhu 35°C atau lebih duty cycle diatur pada nilai tertentu. Jika tombol ditekan dan sistem berubah menjadi nonaktif, motor driver dimatikan dan nilai PWM dibuat nol sehingga kipas berhenti.



Flowchart :



Listing 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) {}
}









1.Analisa bagaimana perbedaan implementasi PWM antara STM32 serta dampaknya terhadap kontrol motor dan LED!
Jawab: PWM pada STM32 dihasilkan oleh timer (misalnya TIM3) dengan mengatur nilai duty cycle melalui register compare. Perubahan duty cycle mempengaruhi lebar pulsa, sehingga:
pada LED → mengatur tingkat kecerahan
pada motor/servo → mengatur posisi atau kecepatan
Semakin besar duty cycle, semakin besar energi yang diberikan ke beban.

2.Analisa bagaimana cara pembacaan nilai sensor analog menggunakan ADC pada STM32!
Jawab: ADC membaca sinyal analog (0–3.3V) lalu mengubahnya menjadi data digital 12-bit (0–4095). Prosesnya:
konfigurasi channel ADC
start konversi (HAL_ADC_Start)
tunggu selesai (HAL_ADC_PollForConversion)
ambil data (HAL_ADC_GetValue)
Nilai ini kemudian digunakan untuk pengambilan keputusan (misalnya threshold LDR).

3.Analisa bagaimana penggunaan interrupt eksternal dalam mendeteksi input dari sensor atau tombol pada STM32!
Jawab: Interrupt eksternal digunakan untuk mendeteksi perubahan input (misalnya tombol) secara langsung tanpa polling. Saat terjadi trigger (falling/rising edge), STM32 menjalankan fungsi callback seperti: 
HAL_GPIO_EXTI_Callback()
Keuntungannya adalah respon cepat dan efisien karena tidak perlu pengecekan terus-menerus di loop.

4.Analisa bagaimana cara kerja fungsi HAL_GetTick() pada STM32!
Jawab: HAL_GetTick() mengembalikan waktu dalam satuan milidetik sejak sistem mulai berjalan. Fungsi ini berbasis timer SysTick dan digunakan untuk:
pengukuran waktu (interval)
delay non-blocking
Contohnya untuk menghitung selang waktu detak atau timeout.

5.Analisa bagaimana perbedaan konfigurasi dan kontrol pin PWM serta pemanfaatan timer internal pada STM32 dalam menghasilkan sinyal PWM!
Jawab: PWM dikonfigurasi dengan:
Prescaler → mengatur resolusi waktu
Period (ARR) → menentukan frekuensi PWM
Compare (CCR) → menentukan duty cycle

Timer internal menghasilkan sinyal periodik, dan perubahan nilai CCR mengubah lebar pulsa tanpa mengubah frekuensi.

6.Bagaimana mengatur pergerakan motor servo pada stm 32?
Jawab: Servo dikontrol dengan PWM frekuensi 50 Hz (periode 20 ms). Posisi ditentukan oleh lebar pulsa:
~1 ms → posisi minimum
~1.5 ms → posisi tengah
~2 ms → posisi maksimum

Di STM32 diatur dengan:
__HAL_TIM_SET_COMPARE()
Perubahan nilai compare mengubah sudut servo (misalnya 1200–1800 µs).



1. Download HTML [disini]

2. Download Rangkaian  [disini]

3. Download Vidio Rangkaian [disini]

4. Download Datasheet Sensor: 

5. Download library Komponen: 

6. Download datasheet Relay [disini]

7. Download datasheet Motor [disini]

8. Download datasheet Led [disini]

9. Download listing program [disini]

10. Download data sheet [disini]

M3 : Tugas Pendahuluan 1

Soal : Jelaskan apa itu protocol UART, SPI, dan I2C? Bagaimana konfigurasi komunikasi UART pada STM 32 F103C8T6 dan STM NUCLEO G474RE pada ...