Laporan Praktikum Mikrokontroler dan Mikroprosesor

Modul 5 – Timer ARM STM32

Pramudya Rakhmadyansyah Sofyan/17524011
Asisten: Arigo Fahreza Putratama
Tanggal praktikum: 25 November 2019
17524011@students.uii.ac.id
Teknik Elektro – Fakultas Teknologi Industri
Universitas Islam Indonesia

Abstrak—Timer merupakan suatu komponen penting pada B. Systick

sebuah mikrokontroler maupun mikroprosesor yang memiliki
peran mengenai masalah pewaktuan dalam menjalankan suatu
perintah. Pada board STM32F407VG, terdapat dua buah metode
pewaktuan, yaitu systick dan timer. Dengan menggunakan board
STM32F407VG serta software Co-IDE, fitur pewaktu pada board
ini dapat diketahui karakteristiknya dengan menjalankan
perintah untuk mengatur waktu LED berkedip. Dari seluruh
praktikum yang telah dilaksanakan, disimpulkan bahwa interval
waktu tunda pada systick dapat ditentukan secara langsung
karena intervalnya sudah fix, sedangkan interval waktu tunda
dari timer perlu ditetukan terlebih dahulu nilai prescaler serta
period-nya.
Kata kumci—Timer; Systick; Interval; Prescaler;
I. PENDAHULUAN
Dalam menjalankan suatu tugas pada suatu perangkat
pemroses, baik itu mikrokontroler maupun mikroprosesor tentu
akan sangat membutuhkan suatu fitur yang dapat mengatur
mengenai masalah pewaktuan sehingga perintah yang diminta
dapat dilaksanakan sebagaimana mestinya. Untuk menjalankan
segala jenis fitur pewaktuan tersebut, maka terdapat salahsatu
fitur bernama timer. Menurut pustaka [1], konsep dasar dari
timer adalah suatu counter yang melakukan pencacahan dari nol
hingga nilai maksimum untuk mencapai kecepatan dan
frekuensi tertentu. Pada praktikum ini, fitur timer akan
dieksplorasi dengan menggunakan board STM32F407VG,
sehingga praktikan mampu unutk mengenal serta memanfaatkan
fitur tersebut pada board ARM STM32.
II. TINJAUAN PUSTAKA
A. Timer STM32F4XX
Pada pustaka [1], dijelaskan bahwa timer merupakan
pencacah yang dapat mengatur interval waktu dari output
sistem, baik itu menggunakan clock internal maupun eksternal.
Pada board STM32F4XX, terdapat berbagai jenis timer dari
mulai TIM1 hingga TIM11 yang memiliki fungsinya masing-
masing, diantaranya yaitu TIM1 dan TIM8 berfungsi sebagai
advanced control timers, TIM2 hingga TIM5 serta TIM9 hingga
TIM14 berfungsi sebagai general-purpose timers, lalu TIM6
dan TIM7 berfungsi sebagai basic timers. Dengan demikian,
fungsi dari timer secara umum diantaranya untuk melaksanakan
tugas secara periodik, menghitung panjang pulsa, mencacah
banyaknya kejadian, serta menghitung waktu tundaan atau
delay.
Menurut pustaka [2], system timer atau biasa juga disebut
sebagai systick, merupakan suatu sistem pewaktuan untuk dapat
menghasilkan interupsi pada interval waktu yang tetap. Dua
diantara dari banyaknya fungsi yang dapat dilakukan oleh
systick, pertama yaitu untuk mengukur waktu yang telah berlalu
dengan mengimplementasikan fungsi time delay. Selanjutnya,
contoh kedua adalah suatu tugas spesifik secara berkala, semisal
penjadwalan kinerja pada CPU yang mana scheduler pada CPU
secara berkala akan memilih proses baru dari antrian proses
yang siap untuk dijalankan berikutnya [2]. Berikut ini adalah
gambar dari flowchart cara kerja pewaktu systick:
Gambar 1 Flowchart Systick
III. METODE PRAKTIKUM
Pada praktikum ini terdapat dua jenis percobaan, yang
pertama yaitu mengatur kedip LED dengan Systick dan yang
kedua yaitu mengatur kedip LED dengan timer. Untuk percoban
pertama, hanya saja program yang digunakannya berbeda.
Terlebih dahulu siapkan board STM32F407VG dan pastikan
modul telah terhubung dengan power supply. Setelah itu,
hubungkan board STM32F407VG dengan pc yang akan
digunakan, lalu tulislah program yang akan digunakan untuk
mengatur LED dengan systick pada software CO-IDE. Program
terlampir. Kemudian, lakukan kompilasi pada program tersebut
dengan menekan menu build. Jika program sudah benar, maka
akan muncul tulisan “BUILD SUCCESSFUL” pada bagian
console, lalu pilih Download Code to Flash untuk melihat hasil
secara real-time pada board STM32F407VG. Setelah hasil
secara real-time dapat diamati, selanjutnya lakukan modifikasi
pada program untuk memvariasikan waktu kedip dari LED.
Selanjutnya, lakukan kembali hal yang sama untuk percobaan Gambar 3 Bagian Program Modifikasi Timer
kedua dengan program yang berbeda untuk dapat mengatur
kedip dari LED dengan menggunakan timer. Program untuk
percobaan kedua terlampir.
IV. HASIL DAN ANALISIS
Setelah praktikum dijalankan sesuai dengan metodologi,
data-data hasil praktikum dari dua percobaan yang didapatkan
berupa gambar dari proses simulasi secara real-time. Dari
kedua percobaan tersebut, hasil berupa gambar yang didapatkan
antara kedua percobaan identic, hanya saja metode waktu
tundaannya yang berbeda. Pada percobaan pertama, waktu
tundaan diatur dengan menggunakan systick. Sebelum
melakukan modifikasi, waktu tundaan yang dihasilkan dari
program tersebut yaitu 1000 ms atau 1 detik, sehingga LED
akan berkedip setiap 1 detik sekali. Untuk melakukan variasi
waktu kedip dari LED, maka bagian program yang dimodifikasi
adalah sebagai berikut:
Gambar 2 Bagian Program Modifikasi Systick

Dari gambar 3, untuk dapat mempercepat waktu kedip dari

LED biru, maka bagian DELAY_Ms diganti dengan nilai yang
lebih kecil sesuai dengan keinginan. Semisal, untuk
mendapatkan waktu LED biru berkedip setiap 1 detik, maka
DELAY_Ms diubah menjadi 1000ms. Kemudian, pada LED
merah, waktu tundaan didapatkan dengan mengatur nilai
prescaler serta period untuk mendapatkan waktu yang
diinginkan. Semisal, untuk mendapatkan waktu tundaan yang
lebih besar, dengan kata lain LED akan berkedip lebih lama,
yaitu setiap 10 detik, maka bagian prescaler diubah menjadi
839. Dari modifikasi tersebut, maka LED biru akan berkedip
Dari gambar 2, untuk mendapatkan waktu tundaan yang sesuai
setiap 1 detik sekali, sedangkan LED merah akan berkedip
dengan kebutuhan, maka bagian set delay diubah sesuai dengan
setiap 10 detik sekali. Program hasil modifikasi terlampir.
yang diinginkan dengan satuan ms. Jika nilai msTick semakin
Berikut ini adalah beberapa gambar hasil simulasi secara real-
tinggi, maka waktu yang diperlukan LED untuk berkedip akan
time pada board STM32F407VG dengan variasi kondisi LED
semakin lama. Sebaliknya, jika nilai msTick semakin rendah,
yang menyala:
maka waktu yang diperlukan LED untuk berkedip akan
Gambar 4 LED merah dan LED Biru Tidak Menyala
semakin cepat. Pada percobaan ini, program dimodifikasi
menjadi 10ms, sehingga hasil real-time yang didapatkan LED
akan berkedip sangat cepat yaitu tiap 10ms sekali. Program
hasil modifikasi terlampir.

Selanjutnya, pada percobaan kedua, LED yang akan

dinyalakan pada percobaan kali ini yaitu menjadi dua buah,
yaitu LED merah dan LED biru. LED merah dan LED biru ini
memiliki metode pewaktuan yang berbeda, di mana LED biru
berkedip sesuai dengan mengatur waktu tundaan, sedangkan
LED merah berkedip dengan mengatur prescaler serta period
untuk mendapatkan waktu tundaan. Dari percobaan ini, LED
biru akan berkedip setiap 250ms sekali, sedangkan LED merah
akan berkedip setiap 500ms. Untuk dapat melakukan variasi
waktu kedip antara kedua LED tersebut, maka bagian program
yang dimodifikasi adalah sebagai berikut:
Gambar 5 LED Merah Menyala V. KESIMPULAN
Dari seluruh percobaan yang telah dilaksanakan, dapat
disimpulkan bahwa timer dan systick merupakan fungsi
pewaktu pada board STM32F407VG yang memiliki metode
pewaktuan yang berbeda. Pada timer, interval dari waktu
tundaan ditentukan dengan menggunakan beberapa parameter,
diantaranya yaitu frekuensi pencacah kejadian, periode, dan
prescaler. Berbeda dengan timer, interval dari waktu tundan
telah ditentukan sebelumnya atau fix. Pada percobaan pertama,
bagian set delay pada systick berfungsi untuk mengatur waktu
tundaan pada LED untuk berkedip. Apabila nilai set delay
semakin kecil, maka waktu LED untuk berkedip akan semakin
cepat. Sebaliknya, apabila nilai set delay semakin besar, maka
waktu LED untuk berkedip semakin lama. Lain halnya dengan
timer, waktu tundaan terlebih dahulu diatur dengan
memasukkan nilai pada prescaler dan period untuk
medapatkan waktu tundaan yang diinginkan. Jika nilai
Gambar 6 LED Biru Menyala prescaler yang digunakan semakin kecil, maka waku LED
untuk berkedip akan semakin lama. Namun, jika presacler yang
digunakan lebih besar, maka waktu LED untuk berkedip akan
semakin cepat.
DAFTAR PUSTAKA
[1] J. T. Elektro, Buku Petunjuk Praktikum
Mikrokontroler dan Mikroprosesor,
Yogyakarta, 2019.

[2] Y. Zhu, ARM Cortex-M System Timer

(SysTick), E-Man Press LLC, 2018.

Gambar 7 Kedua LED Menyala

Lampiran

1.Program Systick sebelum modifikasi

#include "stm32f4xx.h" // Toggle LED
#include "stm32f4xx_rcc.h" GPIO_ToggleBits(GPIOD, GPIO_Pin_13);
#include "stm32f4xx_gpio.h" // Set delay 1s (1000ms)
#include "clock.h" msTick = 1000;
__IO uint32_t msTick; // Wait until msTick is zero
// This function will be called every 1ms while (msTick);
void SysTick_Handler(void) }
{ }
msTick--;
}
int main(void)
{
// Set clock to 168MHz
CLOCK_SetClockTo168MHz();
// Update SystemCoreClock variable
SystemCoreClockUpdate();
// Make SysTick overflow every 1ms
SysTick_Config(SystemCoreClock / 1000);
// Enable clock for GPIOD
RCC_AHB1PeriphClockCmd(RCC_AHB1Peri
ph_GPIOD, ENABLE);
// Initialization for PD13 (orange LED) as output
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_13;
GPIO_InitStruct.GPIO_Mode
= GPIO_Mode_OUT;
GPIO_InitStruct.GPIO_Speed
= GPIO_Speed_2MHz;
GPIO_InitStruct.GPIO_OType
= GPIO_OType_PP;
GPIO_InitStruct.GPIO_PuPd
= GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStruct);
while (1)
{
2.Modifikasi Program Systick
#include "stm32f4xx.h" // Set delay 1s (10ms)
#include "stm32f4xx_rcc.h" msTick = 10;
#include "stm32f4xx_gpio.h" // Wait until msTick is zero
#include "clock.h" while (msTick);
__IO uint32_t msTick; }
// This function will be called every 1ms }
void SysTick_Handler(void)
{
msTick--;
}
int main(void)
{
// Set clock to 168MHz
CLOCK_SetClockTo168MHz();
// Update SystemCoreClock variable
SystemCoreClockUpdate();
// Make SysTick overflow every 1ms
SysTick_Config(SystemCoreClock / 1000);
// Enable clock for GPIOD
RCC_AHB1PeriphClockCmd(RCC_AHB1Peri
ph_GPIOD, ENABLE);
// Initialization for PD13 (orange LED) as output
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_13;
GPIO_InitStruct.GPIO_Mode
= GPIO_Mode_OUT;
GPIO_InitStruct.GPIO_Speed
= GPIO_Speed_2MHz;
GPIO_InitStruct.GPIO_OType
= GPIO_OType_PP;
GPIO_InitStruct.GPIO_PuPd
= GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStruct);
while (1)
{
// Toggle LED
GPIO_ToggleBits(GPIOD, GPIO_Pin_13);
3.Program Percobaan Timer
#include "stm32f4xx.h" DELAY_Ms(2500);
#include "stm32f4xx_rcc.h" }
#include "stm32f4xx_gpio.h" }
#include "stm32f4xx_tim.h" void TIM_INT_Init()
#include "misc.h" {
#include "clock.h" // Enable clock for TIM2
#include "delay.h" RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,
void TIM_INT_Init(void); ENABLE);
void TIM2_IRQHandler() // TIM2 initialization for overflow every 500ms
{ // Update Event (Hz) = timer_clock / ((TIM_Prescaler + 1)
// Checks whether the TIM2 interrupt has occurred or not * (TIM_Period+ 1))
if (TIM_GetITStatus(TIM2, TIM_IT_Update)) // Update Event (Hz) = 84MHz / ((4199 + 1) * (9999 + 1))
{ = 2Hz (0.5s)
// Toggle orange LED (PD13) TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
GPIO_ToggleBits(GPIOD, GPIO_Pin_13); TIM_TimeBaseInitStruct.TIM_Prescaler = 4199;
// Clears the TIM2 interrupt pending bit TIM_TimeBaseInitStruct.TIM_Period = 9999;
TIM_ClearITPendingBit(TIM2, TIM_IT_Update); TIM_TimeBaseInitStruct.TIM_ClockDivision
} = TIM_CKD_DIV1;
} TIM_TimeBaseInitStruct.TIM_CounterMode
int main(void) = TIM_CounterMode_Up;
{ TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStruct);
// Set clock to 168MHz // Enable TIM2 interrupt
CLOCK_SetClockTo168MHz(); TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
// Initialize delay function // Start TIM2
DELAY_Init(); TIM_Cmd(TIM2, ENABLE);
// Enable clock for GPIOD // Nested vectored interrupt settings
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, NVIC_InitTypeDef NVIC_InitStruct;
ENABLE); NVIC_InitStruct.NVIC_IRQChannel = TIM2_IRQn;
// Initialize PD13 and PD15 as output for orange and blue LED NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
GPIO_InitTypeDef GPIO_InitStruct; NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT; NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP; NVIC_Init(&NVIC_InitStruct);
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_15; }
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOD, &GPIO_InitStruct);
// Initialize timer interrupt
TIM_INT_Init();
while (1)
{
// Toggle blue LED (GPIO15) every 2.5s
GPIO_ToggleBits(GPIOD, GPIO_Pin_15);
4.Modifikasi Program Timer DELAY_Ms(1000);
#include "stm32f4xx.h" }
#include "stm32f4xx_rcc.h" }
#include "stm32f4xx_gpio.h" void TIM_INT_Init()
#include "stm32f4xx_tim.h" {
#include "misc.h" // Enable clock for TIM2
#include "clock.h" RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,
#include "delay.h" ENABLE);
void TIM_INT_Init(void); // TIM2 initialization for overflow every 500ms
void TIM2_IRQHandler() // Update Event (Hz) = timer_clock / ((TIM_Prescaler + 1)
{ * (TIM_Period+ 1))
// Checks whether the TIM2 interrupt has occurred or not // Update Event (Hz) = 84MHz / ((439 + 1) * (9999 + 1)) = 2Hz
if (TIM_GetITStatus(TIM2, TIM_IT_Update)) (0.5s)
{ TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
// Toggle orange LED (PD13) TIM_TimeBaseInitStruct.TIM_Prescaler = 439;
GPIO_ToggleBits(GPIOD, GPIO_Pin_13); TIM_TimeBaseInitStruct.TIM_Period = 9999;
// Clears the TIM2 interrupt pending bit TIM_TimeBaseInitStruct.TIM_ClockDivision
TIM_ClearITPendingBit(TIM2, TIM_IT_Update); = TIM_CKD_DIV1;
} TIM_TimeBaseInitStruct.TIM_CounterMode
} = TIM_CounterMode_Up;
int main(void) TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStruct);
{ // Enable TIM2 interrupt
// Set clock to 168MHz TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
CLOCK_SetClockTo168MHz(); // Start TIM2
// Initialize delay function TIM_Cmd(TIM2, ENABLE);
DELAY_Init(); // Nested vectored interrupt settings
// Enable clock for GPIOD NVIC_InitTypeDef NVIC_InitStruct;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, NVIC_InitStruct.NVIC_IRQChannel = TIM2_IRQn;
ENABLE); NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
// Initialize PD13 and PD15 as output for orange and blue LED NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
GPIO_InitTypeDef GPIO_InitStruct; NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT; NVIC_Init(&NVIC_InitStruct);
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP; }
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_15;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOD, &GPIO_InitStruct);
// Initialize timer interrupt
TIM_INT_Init();
while (1)
{
// Toggle blue LED (GPIO15) every 1s
GPIO_ToggleBits(GPIOD, GPIO_Pin_15);