PEMBELAJARAN KENDIRI, FLIP CLASSROOM
Dalam MakeCode, “Basic” ialah kumpulan blok asas yang paling banyak digunakan.
Kalau kita ibaratkan coding macam masak:
“Basic” = bahan asas dapur
(beras, garam, minyak, gula)
Tanpa Basic, susah nak masak apa-apa.
Semua projek micro:bit mesti akan sentuh blok dalam kategori Basic ini.
Buka MakeCode micro:bit di komputer.
Di sebelah kiri, ada senarai kategori blok (Basic, Input, Music, LED, Radio, dll.).
Ikon petak 3x3 biru + tulisan Basic → itulah menunya.
Klik “Basic” → akan keluar banyak blok warna biru.
Saya senaraikan dan terangkan satu-satu dengan bahasa murid.
Fungsi: Kod dalam blok ini akan jalan sekali sahaja masa micro:bit mula hidup.
Contoh guna:
Tunjuk logo sekolah sekali.
Papar “HELLO” sekejap.
Contoh:
on start
show string "HELLO"
Fungsi: Kod dalam blok ini akan berulang-ulang tanpa henti.
Micro:bit akan buat benda sama selagi ada kuasa.
Sesuai untuk:
Animasi LED
Sentiasa baca sensor
Projek yang perlu “live”
Contoh:
forever
show icon ♥
Fungsi: Papar ikon siap sedia (heart, smiley, arrow, dsb.) pada LED 5x5.
Senang untuk murid mula faham paparan.
Contoh:
show icon Heart
Fungsi: Murid boleh lukis sendiri corak pada grid 5x5.
Setiap titik (dot) boleh on/off.
Contoh:
show leds
. # . # .
# . # . #
. # . # .
# . # . #
. # . # .
Fungsi: Papar perkataan atau ayat bergerak melintasi skrin.
Sesuai untuk mesej seperti:
“HELLO”
“SOLAT”
“WELCOME”
Contoh:
show string "ASSALAMUALAIKUM"
(ini blok yang cikgu tanya tadi)
Fungsi: Tunjuk nombor pada skrin LED.
Boleh tunjuk:
Nombor tetap (contoh: 5, 10, 100)
Nombor dalam variable (contoh: skor, langkah, bacaan sensor)
Contoh:
show number 0 // tunjuk nombor 0
show number score // tunjuk nilai skor
Fungsi: Berhenti sekejap sebelum sambung arahan seterusnya.
Nilai dalam ms (millisecond):
1000 ms = 1 saat
Diguna untuk:
Jeda antara paparan
Animasi step by step
Contoh:
show icon Heart
pause (500)
show icon Small Heart
pause (500)
Fungsi: Padam semua LED di skrin.
Sesuai selepas selesai tunjuk nombor / icon / string.
Contoh:
show string "SIAP!"
clear screen
Fungsi:
plot → hidupkan LED di koordinat tertentu.
unplot → padamkan LED di koordinat tertentu.
Sesuai untuk murid faham koordinat (x,y):
x = lajur (0 sampai 4)
y = baris (0 sampai 4)
Contoh:
plot(2, 2) // hidupkan titik di tengah skrin
unplot(2, 2) // padamkan semula titik di tengah
Cikgu boleh cakap macam ni:
“Dalam MakeCode, menu Basic ni macam toolbox asas.
Kalau kita nak micro:bit bercakap (tunjuk teks), tunjuk muka senyum, kira nombor, buat animasi – semua ada dalam Basic.
Hari ni kita belajar kenal semua ‘bahan asas’ dulu, lepas tu baru kita masak projek robotik yang hebat!”
Blok show number digunakan untuk memaparkan nombor pada skrin LED micro:bit.
Dalam contoh gambar, blok menunjukkan:
show number 0
Maksudnya:
👉 Micro:bit akan menayangkan nombor 0 pada skrin 5×5 LED.
Contoh: kira langkah, skor permainan, bil sensor.
show number skor
Contoh: tengok bacaan cahaya, suhu, jarak.
show number light level
Contoh: tunjuk nombor menu, pilihan, timer, countdown.
➡ “Blok ini suruh micro:bit tunjuk nombor apa yang kita letak dalam bulatan putih tu.”
➡ “Kalau kita tukar 0 kepada 50, micro:bit tunjuk 50.”
➡ “Kalau kita letak nama variable, dia tunjuk nilai variable tu.”
on button A pressed
show number 7
Klik link ini untuk melihat contoh
👉 Tekan A → micro:bit tunjuk nombor 7.
steps = steps + 1
show number steps
👉 Micro:bit tunjuk jumlah langkah terkini.
show number temperature
👉 Tunjuk suhu.
“Blok show number ni macam kalkulator — bila kita tekan, dia tunjuk nombor atas skrin.”
Blok show leds digunakan untuk melukis gambar sendiri pada skrin LED micro:bit yang berukuran 5×5 titik.
Micro:bit ada 25 lampu LED (5 baris × 5 lajur).
Dengan blok ini, kita boleh pilih LED mana nak hidup (on) atau padam (off).
Di dalam blok show leds, ada satu grid 5×5:
# (atau titik yang menyala) → LED HIDUP
. (titik kosong) → LED MATI
Contoh grid:
# . # . #
. # . # .
# # # # #
. # . # .
# . # . #
Setiap baris mewakili 1 baris LED micro:bit, setiap titik mewakili 1 lampu.
Bayangkan blok show leds sebagai kertas graf 5×5:
Kalau murid warnakan petak → lampu menyala.
Kalau murid biarkan kosong → lampu padam.
Jadi, murid boleh melukis:
✔ Hati ❤️
✔ Anak panah ➡
✔ Senyuman 🙂
✔ A huruf A
✔ Animasi (bergerak!)
. # . # .
# # # # #
# # # # #
. # # # .
. . # . .
. . # . .
. . . . .
# . . . #
. # . # .
. . # . .
🔹 Bila nak buat gambar custom
🔹 Bila nak buat animasi step-by-step
🔹 Bila nak ajar murid koordinat X & Y
🔹 Bila nak cipta simbol sendiri yang tiada dalam “show icon”
Gambar cinta berkelip-kelip:
basic.forever(function () {
basic.showLeds(`
. # . # .
# # # # #
# # # # #
. # # # .
. . # . .
`)
basic.pause(300)
basic.clearScreen()
basic.pause(300)
})
Klik CONTOH untuk lihat contoh
“Blok show leds ni macam kita melukis pixel art.
Kalau kita hidupkan lampu → jadi gambar.
Kalau kita padamkan → jadi gelap.
Dengan blok ni, kamu boleh cipta apa-apa gambar sendiri!”
Blok show icon digunakan untuk memaparkan ikon siap sedia pada skrin LED 5×5 micro:bit.
Micro:bit sudah menyediakan banyak ikon seperti:
❤️ ikon hati
🙂 ikon senyum
😢 ikon sedih
⬅➡ anak panah
✔ tanda betul
✖ tanda salah
♦ diamond
🐤 duck
☀ matahari
dan banyak lagi.
Dengan blok ini, murid tak perlu melukis sendiri seperti show leds.
Hanya pilih ikon daripada senarai, dan micro:bit akan tunjukkannya.
✔ Memudahkan paparan visual
✔ Memberikan maklum balas cepat kepada murid
✔ Menunjukkan simbol tertentu tanpa perlu lukis manual
✔ Sesuai untuk projek ringkas & pembelajaran awal
“Blok show icon ni macam butang emoji dalam WhatsApp.
Tekan je → keluar emoji tu atas micro:bit!”
Pada blok show icon, ada gambar ikon kecil.
Murid boleh klik anak panah kecil untuk pilih ikon lain.
Contoh:
show icon Heart
show icon Happy
show icon Sad
show icon ArrowWest
Setiap ikon ada bentuk tetap pada grid 5×5.
input.onButtonPressed(Button.A, function () {
basic.showIcon(IconNames.Happy)
})
input.onButtonPressed(Button.B, function () {
basic.showIcon(IconNames.Sad)
})
basic.showIcon(IconNames.Heart)
basic.pause(500)
basic.showIcon(IconNames.SmallHeart)
Klik CONTOH untuk melihat contoh
show icon
Papar ikon siap sedia yang sudah ada dalam MakeCode
show leds
Murid lukis sendiri corak 5×5
Murid boleh faham macam ini:
🟦 show icon → siap terus (emoji).
🟧 show leds → lukis manual.
“Blok show icon ialah paparan emoji siap sedia.
Hanya pilih ikon — micro:bit akan tunjuk terus!”
Blok show string digunakan untuk memaparkan perkataan atau ayat pada skrin LED micro:bit.
Perkataan akan bergerak dari kanan ke kiri (scrolling).
Contohnya jika tulis "Hello!", micro:bit akan tayang:
H → e → l → l → o → !
Satu huruf muncul sekali, kemudian bergerak ke kiri sampai habis.
✔ Memaparkan teks kepada pengguna
✔ Sesuai untuk mesej ringkas
✔ Boleh beri maklum balas seperti:
“WELCOME”
“READY”
“MULA”
“TAHNIAH!”
“ERROR”
“Blok show string ni macam micro:bit sedang menulis ayat berjalan.
Kita taip apa dalam kotak putih, micro:bit akan baca dan tunjuk perkataan tu di skrin.”
Murid boleh tulis:
Perkataan: "Hello"
Ayat: "Saya Husza"
Nama kelas: "6 Bestari"
Pesanan: "Solat!"
Emosi: "Happy"
Semua tulisan mesti berada dalam tanda petik
Contoh:
"Assalamualaikum"
"Good Job!"
"SK LOK HENG SELATAN"
basic.showString("HELLO")
input.onButtonPressed(Button.A, function () {
basic.showString("GO!")
})
basic.showString("AMIR")
basic.showString("NURUL")
Klik CONTOH untuk melihat contoh
show string
Papar huruf / perkataan yang bergerak
show icon
Papar ikon siap sedia
show leds
Murid lukis gambar sendiri 5×5
“Show string = micro:bit tunjuk perkataan berjalan di skrin.
Kita taip ayat → micro:bit baca dan paparkan.”
Blok clear screen digunakan untuk memadam semua lampu LED pada skrin micro:bit.
Apa sahaja yang sedang dipaparkan — sama ada:
ikon
teks
nombor
gambar
lampu satu titik (plot)
animasi
…semuanya akan hilang dan skrin kembali kosong / gelap.
basic.clearScreen()
“clear screen ni macam butang padam papan putih.
Kalau micro:bit tengah tunjuk gambar atau ayat, tekan block ini → semua hilang.”
✔ Untuk hentikan paparan lama
✔ Untuk beri ruang paparan baru
✔ Untuk buat animasi (blink, flash effect)
✔ Untuk reset skrin sebelum tunjuk mesej seterusnya
✔ Untuk kurangkan penggunaan bateri (LED padam)
basic.showString("HELLO")
basic.clearScreen()
basic.forever(function () {
basic.showIcon(IconNames.Heart)
basic.pause(300)
basic.clearScreen()
basic.pause(300)
})
Hati → hilang → hati → hilang (berkelip-kelip)
basic.showNumber(8)
basic.pause(1000)
basic.clearScreen()
basic.plot(2, 2)
basic.pause(500)
basic.clearScreen()
basic.showString("HELLO")
basic.clearScreen()
📝 Apa jadi?
Micro:bit tulis "HELLO", selesai sahaja → skrin terus kosong.
basic.forever(function () {
basic.showIcon(IconNames.Heart)
basic.pause(300)
basic.clearScreen()
basic.pause(300)
})
📝 Apa jadi?
Ikon hati → skrin kosong → ikon hati → skrin kosong.
Kesan: berkelip-kelip (blinking).
basic.showNumber(5)
basic.pause(1000)
basic.clearScreen()
📝 Micro:bit tunjuk nombor 5 selama 1 saat → padam.
input.onButtonPressed(Button.A, function () {
basic.showIcon(IconNames.Happy)
basic.pause(500)
basic.clearScreen()
})
📝 Tekan A → micro:bit tunjuk muka senyum → setengah saat kemudian padam.
basic.plot(2, 2)
basic.pause(500)
basic.clearScreen()
📝 Titik tengah hidup → 0.5 saat → skrin kosong.
basic.forever(function () {
basic.showLeds(`
. . # . .
. # . # .
# . . . #
. # . # .
. . # . .
`)
basic.pause(300)
basic.clearScreen()
basic.pause(300)
})
📝 Corak muncul → hilang → muncul → hilang.
basic.showString("HAI")
basic.clearScreen()
basic.pause(300)
basic.showString("CIKGU HUSZA")
basic.clearScreen()
"basic.clearScreen() = padam semua lampu LED."
Klik CONTOH untuk lihat contoh
“clear screen = padam semua lampu micro:bit.”
Kalau skrin tengah tunjuk apa-apa, blok ini akan kosongkan semuanya.
Blok forever digunakan untuk menjalankan arahan secara berulang-ulang tanpa henti.
Ia bermula sebaik sahaja micro:bit hidup
Ia tidak akan berhenti selagi micro:bit masih ada kuasa
Kod dalam blok ini akan ulang, ulang, ulang… selama-lamanya
Dalam JavaScript, blok ini menjadi:
basic.forever(function () {
// arahan di sini akan berulang tanpa henti
})
“Blok forever ni macam micro:bit bernafas.
Apa yang kita letak dalam blok ini, micro:bit akan buat tanpa berhenti.”
Contoh:
Jika letak show icon ♥ dalam forever, micro:bit akan tunjuk hati selama-lamanya.
✔ Untuk paparan yang perlu kekal (ikon / nombor)
✔ Untuk animasi
✔ Untuk membaca sensor secara berterusan
✔ Untuk memantau keadaan (gelap/cerah, panas/sejuk, dekat/jauh)
✔ Untuk projek robotik yang “sentiasa hidup”
basic.forever(function () {
basic.showIcon(IconNames.Heart)
})
basic.forever(function () {
basic.showIcon(IconNames.Happy)
basic.pause(300)
basic.clearScreen()
basic.pause(300)
})
basic.forever(function () {
if (input.lightLevel() < 50) {
basic.showIcon(IconNames.Asleep)
} else {
basic.clearScreen()
}
})
basic.forever(function () {
basic.showNumber(input.temperature())
basic.pause(1000)
})
basic.forever(function () {
led.plot(0, 2)
basic.pause(100)
basic.clearScreen()
led.plot(4, 2)
basic.pause(100)
basic.clearScreen()
})
Klik CONTOH untuk lihat contoh
on start
Jalan sekali sahaja bila micro:bit hidup
forever
Jalan berulang-ulang tanpa henti
“Forever = buat selagi hidup.”
Apa dalam blok ini akan jalan berkali-kali tanpa berhenti.
Blok on start digunakan untuk menjalankan arahan sekali sahaja apabila micro:bit mula hidup atau di-reset.
Ini bermaksud:
Bila micro:bit ON → arahan dalam on start berjalan
Bila tekan reset → berjalan sekali lagi
Selepas siap → ia tidak berulang-ulang
basic.showString("Hello")
Atau jika ada lebih banyak kod:
basic.showString("HELLO")
basic.showIcon(IconNames.Happy)
basic.pause(500)
(Tiada function khas, kerana “on start” ialah bahagian permulaan program di JavaScript.)
✔ Papar mesej selamat datang
✔ Set nilai awal (initial value)
✔ Tunjuk logo sekolah / greeting
✔ Prepare robot sebelum mula
✔ Set variable ke 0
✔ Hidupkan/Mati komponen pada permulaan
“on start ialah apa yang micro:bit buat sebaik sahaja dia bangun dari tidur.”
Ia hanya berlaku sekali sahaja, bukan berulang.
basic.showString("HELLO")
basic.showIcon(IconNames.Heart)
let skor = 0
basic.showString("WELCOME")
basic.showIcon(IconNames.Happy)
basic.pause(1000)
basic.clearScreen()
let kira = 0
basic.showString("READY")
basic.forever(function () {
kira++
basic.showNumber(kira)
basic.pause(500)
})
➡ On start → tulis READY
➡ Forever → mula kira nombor
on start
Jalan sekali sahaja ketika ON
forever
Jalan tanpa henti selagi micro:bit hidup
Klik CONTOH untuk lihat contoh
“on start = apa micro:bit buat sebaik sahaja hidup.”
“Sekali sahaja, bukan ulang.”
Blok pause (ms) digunakan untuk memberhentikan sementara (jeda) program micro:bit untuk bilangan masa tertentu.
ms = milliseconds
1000 ms = 1 saat
500 ms = 0.5 saat
100 ms = 0.1 saat
Masukkan nilai dalam kotak itu untuk tentukan berapa lama micro:bit berhenti sebelum sambung arahan seterusnya.
basic.pause(100)
(Atau tukar 100 kepada apa-apa nilai lain.)
“Pause ni macam micro:bit berhenti sekejap untuk bernafas, sebelum sambung kerja.”
Kalau tiada pause → animasi jadi terlalu laju
Kalau ada pause → animasi jadi cantik dan kemas
✔ Animasi (blink, berkelip, bergerak)
✔ Jarakkan masa antara dua paparan
✔ Jeda sebelum sambung arahan lain
✔ Menunggu sensor stabil
✔ Kontrol kelajuan robot
✔ Menjaga turutan arahan supaya tidak terlalu laju
basic.pause(1000)
basic.forever(function () {
basic.showIcon(IconNames.Heart)
basic.pause(300)
basic.clearScreen()
basic.pause(300)
})
basic.showString("HELLO")
basic.pause(500)
basic.clearScreen()
for (let x = 0; x <= 4; x++) {
led.plot(x, 2)
basic.pause(200)
led.unplot(x, 2)
}
basic.forever(function () {
basic.showNumber(input.temperature())
basic.pause(1000)
})
Klik CONTOH untuk lihat contoh
100 ms
animasi laju
300 ms
blink cantik
500 ms (0.5s)
jeda standard
1000 ms (1s)
paparan lambat atau bacaan sensor
“pause = berhenti sekejap.”
Micro:bit tunggu ikut masa yang ditetapkan, kemudian sambung kerja.
Blok show arrow digunakan untuk memaparkan anak panah (arrow) pada skrin LED micro:bit.
Murid boleh pilih arah:
North (atas)
South (bawah)
East (kanan)
West (kiri)
NorthEast
SouthEast
SouthWest
NorthWest
Setiap pilihan akan menukar bentuk arrow pada paparan micro:bit.
basic.showArrow(ArrowNames.North)
Kalau pilih arah lain, contohnya West:
basic.showArrow(ArrowNames.West)
“Blok show arrow ni tunjuk anak panah atas skrin micro:bit.
Kita boleh pilih nak panah menghala ke mana.”
Kanak-kanak mudah faham sebab micro:bit akan tunjuk arah macam kompas.
✔ Projek kompas (arah Utara)
✔ Petunjuk dalam permainan
✔ Arah bergerak robot
✔ Animasi arrow bergerak
✔ Tutorial navigasi (left/right/up/down) untuk murid
Contoh arrow North (ke atas):
. # . . .
# . # . .
. . # . .
. . # . .
. . # . .
(Ini LED pattern automatik MakeCode.)
basic.showArrow(ArrowNames.North)
input.onButtonPressed(Button.A, function () {
basic.showArrow(ArrowNames.West)
})
input.onButtonPressed(Button.B, function () {
basic.showArrow(ArrowNames.East)
})
basic.forever(function () {
basic.showArrow(ArrowNames.North)
basic.pause(300)
basic.showArrow(ArrowNames.East)
basic.pause(300)
basic.showArrow(ArrowNames.South)
basic.pause(300)
basic.showArrow(ArrowNames.West)
basic.pause(300)
})
input.onGesture(Gesture.Shake, function () {
basic.showArrow(ArrowNames.South)
})
Klik CONTOH untuk lihat contoh
“show arrow = tunjuk anak panah ikut arah yang kita pilih.”
Kategori Input ialah kumpulan blok yang digunakan untuk mengesan tindakan atau keadaan yang berlaku pada micro:bit.
“Input” bermaksud apa yang micro:bit terima daripada:
sentuhan
butang
pergerakan
bunyi
cahaya
suhu
logo touch
compass
timer
Semua blok Input digunakan untuk memberitahu micro:bit bila perlu bertindak.
“Input = apa yang kita buat pada micro:bit, dan micro:bit akan bagi respon.”
Contoh:
Kita tekan Button A → micro:bit tunjuk icon.
Kita goncang → micro:bit bunyi alarm.
Kita sentuh logo → micro:bit tunjuk hati.
Kategori Input memberi kemampuan micro:bit untuk:
✔ Mengesan butang ditekan
✔ Mengesan gerakan seperti shake, tilt, free fall
✔ Mengesan logo touch (sentuh logo atas)
✔ Mengesan bunyi kuat
✔ Membaca suhu
✔ Membaca cahaya
✔ Membaca compass heading
✔ Mengesan pin tertentu disentuh (digital/analog input)
Input digunakan untuk mengaktifkan sesuatu kod.
Aktif bila butang ditekan.
Aktif bila micro:bit digerakkan.
Aktif bila logo micro:bit disentuh.
Aktif bila sensor bunyi mengesan bunyi kuat.
Baca suhu.
Baca tahap cahaya.
Baca arah kompas (0 – 360°).
Aktif apabila pin P0, P1, P2 disentuh.
input.onButtonPressed(Button.A, function () {
basic.showIcon(IconNames.Heart)
})
input.onGesture(Gesture.Shake, function () {
music.playTone(440, music.beat(BeatFraction.Half))
})
basic.forever(function () {
if (input.lightLevel() > 150) {
basic.showIcon(IconNames.Sun)
}
})
Input = deria micro:bit.
Input membolehkan micro:bit “merasai” apa yang berlaku di sekeliling seperti:
sentuhan, cahaya, bunyi, gerakan, butang, suhu dan pin.
Blok on button A pressed digunakan untuk mengesan bila butang A ditekan pada micro:bit.
Apabila butang A ditekan:
➡ micro:bit akan menjalankan semua arahan yang berada di dalam blok tersebut.
Jika butang tidak ditekan → arahan tidak akan berjalan.
input.onButtonPressed(Button.A, function () {
// Kod yang kita mahu jalankan bila butang A ditekan
})
“Blok ini macam loceng.
Bila kita tekan butang A, micro:bit akan buat apa yang kita suruh dalam blok itu.”
✔ Mengaktifkan sesuatu tindakan hanya bila ditekan
✔ Kawal animasi
✔ Kawal permainan
✔ Ubah mode (contoh Mode 1, Mode 2)
✔ Kawal output tertentu (bunyi, LED, motor, servo)
✔ Trigger fungsi (contoh reset skor)
Melalui dropdown, murid boleh memilih:
A
B
A+B (tekan kedua-duanya serentak)
Logo (jika guna MakeCode V3)
input.onButtonPressed(Button.A, function () {
basic.showIcon(IconNames.Heart)
})
input.onButtonPressed(Button.A, function () {
basic.showString("HELLO")
})
let kira = 0
input.onButtonPressed(Button.A, function () {
kira = kira + 1
basic.showNumber(kira)
})
input.onButtonPressed(Button.A, function () {
music.playTone(440, music.beat(BeatFraction.Whole))
})
input.onButtonPressed(Button.A, function () {
led.plot(2, 2) // hidupkan LED tengah
})
input.onButtonPressed(Button.A, function () {
basic.clearScreen()
})
Klik CONTOH untuk lihat contoh
Blok ini berfungsi berdasarkan event (peristiwa).
Event berlaku apabila:
Button A ditekan → trigger event → jalankan kod.
Jika tiada peristiwa → tiada apa berlaku.
“Kalau kita tekan butang A, micro:bit akan buat perkara yang kita tulis dalam blok ini.”
Blok on button A+B pressed digunakan untuk mengesan bila BUTANG A dan BUTANG B ditekan serentak pada micro:bit.
➡ Micro:bit hanya akan menjalankan arahan dalam blok ini jika butang A dan B ditekan pada masa yang sama.
➡ Jika hanya A ditekan, atau hanya B ditekan, kod ini tidak akan berjalan.
input.onButtonPressed(Button.AB, function () {
// Arahan di sini berjalan apabila A+B ditekan serentak
})
“Blok ini aktif bila kita tekan kedua-dua butang A dan B serentak.
Macam butang ‘special mode’.”
✔ Membuka mode khas
✔ Menukar mod robot (contoh: manual → auto)
✔ Menjalankan fungsi tambahan
✔ Reset keseluruhan program
✔ Menunjukkan mesej rahsia
✔ Gabungan kawalan A, B dan A+B untuk 3 fungsi berbeza
input.onButtonPressed(Button.AB, function () {
basic.showIcon(IconNames.Heart)
})
let skor = 0
input.onButtonPressed(Button.AB, function () {
skor = 0
basic.showString("RESET")
})
input.onButtonPressed(Button.AB, function () {
basic.clearScreen()
})
let mode = 1
input.onButtonPressed(Button.AB, function () {
mode = mode + 1
if (mode > 3) {
mode = 1
}
basic.showNumber(mode)
})
Klik CONTOH untuk melihat coding dalam makecode
input.onButtonPressed(Button.AB, function () {
music.beginMelody(music.builtInMelody(Melodies.Nyan), MelodyOptions.Once)
})
A pressed
Tekan A sahaja
B pressed
Tekan B sahaja
A+B pressed
Tekan A dan B serentak
“A+B pressed = tekan dua-dua butang pada masa yang sama untuk aktifkan fungsi khas.”
Blok on shake digunakan untuk mengesan pergerakan goncangan (shake) pada micro:bit.
Micro:bit ada sensor khas bernama accelerometer, yang boleh merasai:
goncangan
pergerakan kuat
hentakan ringan
Apabila micro:bit digoncang, barulah arahan di dalam blok ini akan dijalankan.
Jika micro:bit tidak digoncang, arahan dalam blok ini tidak akan berjalan.
input.onGesture(Gesture.Shake, function () {
// Arahan di sini berlaku apabila micro:bit digoncang
})
“Blok on shake akan aktif bila kita goncangkan micro:bit macam maracas.
Bila bergoyang, micro:bit mula buat kerja.”
✔ Buat alarm gegaran
✔ Baling dadu digital
✔ Ubah mod dengan shake
✔ Hidupkan bunyi bila jatuh
✔ Projek permainan (contoh: shake = fire!)
✔ Animasi kejutan
input.onGesture(Gesture.Shake, function () {
basic.showIcon(IconNames.Surprised)
})
input.onGesture(Gesture.Shake, function () {
music.playTone(440, music.beat(BeatFraction.Half))
})
input.onGesture(Gesture.Shake, function () {
basic.showNumber(randint(1, 6))
})
input.onGesture(Gesture.Shake, function () {
basic.clearScreen()
})
input.onGesture(Gesture.Shake, function () {
basic.showString("STOP!")
})
Selain shake, dropdown boleh pilih:
tilt left
tilt right
screen up
screen down
free fall
face up
face down
3G / 6G / 8G (pergerakan kuat)
Dalam JavaScript contohnya:
input.onGesture(Gesture.TiltLeft, function () {
basic.showIcon(IconNames.ArrowWest)
})
Klik CONTOH untuk lihat coding dalam makecode
Micro:bit menggunakan accelerometer untuk mengesan:
gegaran
kelajuan
arah condongan
hentakan kecil
Ini digunakan dalam projek-pergerakan dan permainan.
“on shake = bila kita goncang micro:bit, barulah kod ini berjalan.”
Blok ini ialah blok peristiwa (event block) untuk micro:bit dalam MakeCode.
Micro:bit ada sensor accelerometer yang boleh rasa arah condongan papan.
“logo up” bermaksud:
Papan micro:bit dipusing supaya bahagian logo tulisan “micro:bit” berada di atas.
LED masih menghadap ke hadapan, tetapi papan itu ditegakkan / ditilt sehingga logo berada di bahagian atas.
Apabila sensor mengesan keadaan ini, peristiwa “logo up” berlaku.
Blok ini menunggu sehingga micro:bit berada dalam posisi logo up.
Bila posisi itu berlaku, SEMUA arahan yang kita letak di dalam blok ini akan dijalankan sekali dari atas ke bawah.
Kalau kedudukan berubah dan kemudian logo up lagi, arahan di dalamnya akan dijalankan sekali lagi.
Dalam JavaScript, blok ini sama seperti:
input.onGesture(Gesture.LogoUp, function () {
// arahan di dalam blok
})
Blok ungu ini sendiri tidak buat apa-apa kalau kosong.
Kita mesti letak blok lain dalam ruang putih di bawahnya, contoh:
show leds → paparkan gambar
play tone → bunyikan buzzer
radio send number → hantar nombor melalui radio
Jadi ia berfungsi sebagai pemicu: “BILA logo micro:bit menghala ke atas, BUAT semua perkara ini.”
“Blok on logo up bermaksud: bila kita condongkan micro:bit sampai logo berada di atas, micro:bit akan jalankan semua arahan yang kita letak dalam blok ini.”
Blok ini ialah blok peristiwa (event block) yang mengesan orientasi fizikal micro:bit menggunakan sensor accelerometer.
Micro:bit ada tulisan/logo “micro:bit” pada bahagian depan papan (di bawah LED).
“Logo down” bermaksud:
➡️ Logo micro:bit berada di bahagian bawah / menghadap ke lantai.
➡️ Micro:bit dalam keadaan menunduk / menekup ke bawah.
Dengan kata lain:
Bahagian atas micro:bit menghala ke bawah.
Bahagian LED condong ke hadapan seperti bowing (menunduk).
Apabila sensor accelerometer mengesan posisi ini, event “logo down” akan diaktifkan.
Contoh dalam JavaScript:
input.onGesture(Gesture.LogoDown, function () {
// arahan di sini akan berjalan
})
Accelerometer micro:bit mengesan:
arah graviti,
kecondongan papan,
perubahan posisi.
Apabila graviti menunjukkan micro:bit condong ke bawah (logo menghala ke lantai), maka:
➡ Event “logo down” dicetuskan → arahan di dalam blok dijalankan.
Jika posisi berubah → tiada apa berlaku.
Jika condong ke bawah semula → event akan aktif sekali lagi.
Blok ini tidak melakukan apa-apa kalau kosong.
Ia perlu diisi dengan arahan seperti:
show icon
play sound
radio send number
set servo angle
change score by 1
Contoh mudah:
“BILA micro:bit menunduk ke bawah, TUNJUK icon sedih.”
input.onGesture(Gesture.LogoDown, function () {
basic.showIcon(IconNames.Sad)
})
input.onGesture(Gesture.LogoDown, function () {
radio.sendString("down")
})
“Blok on logo down bermaksud: bila micro:bit ditundukkan sehingga logo menghadap ke bawah, micro:bit akan buat semua arahan yang kita letak dalam blok ini.”
screen = bahagian hadapan micro:bit yang ada LED 5x5.
screen up bermaksud:
Micro:bit diletakkan terlentang di atas meja.
LED menghadap ke langit / ke atas.
Belakang papan (yang ada pin, bateri, cip) menghadap ke meja.
Apabila micro:bit berada dalam posisi ini, sensor accelerometer mengesan bahawa skrin (LED) menghala ke atas.
Blok:
on screen up
// arahan di dalam
bermakna:
“BILA skrin micro:bit menghadap ke atas, JALANKAN semua arahan di dalam blok ini.”
Ia menunggu sehingga keadaan screen up berlaku.
Bila dikesan, semua blok yang diletakkan di ruang putih akan dijalankan sekali dari atas ke bawah.
Jika kedudukan berubah dan kemudian screen up lagi, arahan akan dijalankan lagi.
Dalam JavaScript, blok ini bersamaan dengan:
input.onGesture(Gesture.ScreenUp, function () {
// arahan di sini
})
Kalau ruang dalam blok kosong → tiada tindakan.
Kita mesti isi dengan arahan lain, contohnya:
basic.showIcon(IconNames.Happy)
music.playTone(...)
radio.sendNumber(1)
pins.servoWritePin(...) dan sebagainya.
Jadi blok ini bertindak sebagai “suiz pemula” berdasarkan cara kita meletakkan micro:bit.
“Blok on screen up maksudnya: bila micro:bit diletakkan terlentang dan lampu LED menghadap ke atas, micro:bit akan jalankan semua arahan yang kita letak dalam blok ini.”
Blok ini ialah blok peristiwa (event block) yang dikuasakan oleh sensor accelerometer dalam micro:bit.
Ia digunakan untuk mengesan orientasi micro:bit.
“Screen” merujuk kepada bahagian depan micro:bit yang ada:
Paparan LED 5×5
Logo micro:bit
A/B buttons
“Screen down” bermaksud:
Situasi ini seperti:
Kita letakkan micro:bit di atas meja dengan LED menghadap ke meja.
Atau kita pusing micro:bit sehingga bahagian LED berarah ke bawah.
Sensor accelerometer akan mengesan keadaan ini dan mencetuskan peristiwa “screen down”.
Blok:
on screen down
// arahan di sini
bermaksud:
BILA skrin micro:bit menghadap ke bawah, barulah semua arahan dalam blok ini dijalankan.
Ia hanya “bangun” dan bertindak apabila micro:bit berada dalam orientasi screen down.
Peristiwa ini dipanggil once per trigger:
Jika murid terbalikkan micro:bit → event berlaku
Bila murid angkat → event berhenti
Bila murid terbalikkan lagi → event berlaku semula
Dalam JavaScript, ia bersamaan dengan:
input.onGesture(Gesture.ScreenDown, function () {
// your code here
})
Blok ini ialah “pemicu peristiwa” sahaja.
Ia mesti diisi dengan blok lain, contoh:
basic.showIcon(IconNames.Asleep)
music.playTone(…, …)
radio.sendNumber(1)
pins.servoWritePin(...)
led.plot(x, y)
Jika tiada arahan dimasukkan → tiada apa berlaku walaupun skrin menghadap ke bawah.
“Blok on screen down bermaksud bila micro:bit diletakkan menelungkup dan lampu LED menghadap ke bawah, micro:bit akan buat semua arahan yang kita letak dalam blok ini.”
Blok ini adalah blok peristiwa (event block) yang menggunakan sensor accelerometer dalam micro:bit untuk mengesan kecondongan (tilt) ke arah kiri.
“tilt left” bermaksud:
Ibarat:
Kita memegang micro:bit seperti telefon.
Kemudian kita sengetkan tangan ke kiri.
Sensor accelerometer akan mengesan perubahan arah graviti ini dan mencetuskan peristiwa tilt left.
Blok ini:
on tilt left
// arahan di sini
berfungsi sebagai:
“BILA micro:bit disendengkan ke kiri, JALANKAN semua arahan yang berada di dalam blok ini.”
Perkara penting:
Ia hanya aktif bila condong ke kiri.
Bila kembali ke kedudukan normal → tidak aktif.
Jika condong ke kiri lagi → ia akan dijalankan semula (trigger sekali setiap kali terjadinya kecondongan).
Dalam JavaScript, ia bersamaan dengan:
input.onGesture(Gesture.TiltLeft, function () {
// code here
})
Blok ini sendiri tidak melakukan apa-apa jika dibiarkan kosong.
Ia mesti diisi dengan arahan lain, contoh:
basic.showArrow(ArrowNames.West)
music.playTone(...)
radio.sendString("left")
servo.writePin(...)
score += 1
Jadi, fungsi sebenar blok ini ialah mengikut arahan yang kita letak bergantung pada pergerakan fizikal micro:bit.
“Bila kita sengetkan micro:bit ke kiri, arahan dalam blok on tilt left akan dijalankan.”
Blok ini ialah blok peristiwa (event block) yang menggunakan accelerometer dalam micro:bit untuk mengesan apabila micro:bit dicondongkan ke arah kanan.
“tilt right” bermaksud micro:bit berada dalam keadaan:
Situasi ini seperti:
Kita memegang micro:bit seperti telefon.
Kemudian kita miringkan ke kanan seperti hendak belok kanan dalam game.
Sensor accelerometer akan mengesan pergerakan condong tersebut dan membaca graviti yang menarik ke arah kanan.
Blok:
on tilt right
// arahan di sini
akan berfungsi sebagai:
“BILA micro:bit disendengkan ke kanan, jalankan semua arahan di dalam blok ini.”
Ciri penting:
Ia hanya mencetuskan event apabila micro:bit benar-benar condong ke kanan.
Apabila kembali ke posisi neutral → tiada tindakan.
Apabila condong ke kanan lagi → event akan diaktifkan semula.
Dalam JavaScript, ia sama dengan:
input.onGesture(Gesture.TiltRight, function () {
// your code here
})
Ia perlu diisi dengan arahan lain, contohnya:
Menunjukkan ikon → basic.showArrow(ArrowNames.East)
Bunyi beep → music.playTone(...)
Kawal robot belok kanan → radio.sendString("right")
Tambah skor game → score += 1
Aktifkan servo atau motor
Blok ini hanyalah pemicu (trigger) berdasarkan pergerakan fizikal micro:bit.
“Bila kita sengetkan micro:bit ke kanan, benda dalam blok on tilt right akan dijalankan.”
Free fall = jatuh bebas
Berlaku bila micro:bit dilepaskan dan sedang jatuh di udara.
Dalam keadaan ini, micro:bit dan sensor accelerometer berada dalam keadaan “berat sifar” (0g) sekejap.
Sensor akan mengesan bahawa hampir tiada daya yang menekan pada micro:bit → itulah yang dipanggil free fall.
Contoh:
Cikgu pegang micro:bit di tangan.
Cikgu lepaskan (drop) micro:bit ke atas tilam / span.
Semasa ia jatuh, beberapa milisaat itu dikira free fall.
⚠️ Untuk murid: buat eksperimen ini atas permukaan lembut supaya micro:bit tidak rosak.
Bentuk blok:
on free fall
// arahan di dalam
Maksudnya:
“BILA micro:bit dikesan sedang jatuh bebas, JALANKAN semua arahan di dalam blok ini.”
Blok ini menunggu sehingga accelerometer kesan keadaan free fall.
Bila dikesan, semua blok yang kita letak di ruang putih akan dijalankan sekali.
Jika micro:bit jatuh lagi (free fall lagi), arahan akan dijalankan sekali lagi.
Dalam JavaScript, sama dengan:
input.onGesture(Gesture.FreeFall, function () {
// arahan di sini
})
Blok ungu ini tidak buat apa-apa kalau kosong.
Kita mesti isi dengan arahan lain, contohnya:
basic.showIcon(IconNames.Surprised) → paparkan muka terkejut bila jatuh
music.playTone(...) → bunyi “alarm jatuh”
radio.sendString("jatuh!") → hantar mesej ke micro:bit lain
game.removeLife(1) → kurangkan nyawa dalam game bila pemain jatuhkan micro:bit
Jadi fungsi sebenar blok ini ialah:
menggunakan pergerakan “jatuh” micro:bit sebagai suis untuk memulakan tindakan yang kita pilih.
“Blok on free fall bermaksud: bila micro:bit sedang jatuh bebas (kita lepaskan dari tangan), micro:bit akan jalankan semua arahan yang kita letak dalam blok ini.”
Blok ini adalah blok “event” yang digunakan untuk mengesan pergerakan tertentu pada micro:bit. Ia biasanya berada dalam kategori Input → Accelerometer.
“3g” merujuk kepada daya pecutan (acceleration force) sebanyak 3 kali g-force.
“g” = graviti bumi (9.8 m/s²).
Jadi, apabila micro:bit menerima hentakan, gegaran, atau pergerakan yang kuat (sekitar 3g), blok ini akan dipicu (trigger).
👉 Blok ini menjalankan kod di dalamnya apabila micro:bit mengesan hentakan atau pergerakan KUAT yang sama atau melebihi 3g.
Maknanya:
Bila micro:bit dihentak,
atau jatuh lalu berhenti tiba-tiba,
atau digoncang kuat,
atau terkena pergerakan mengejut,
… maka arahan di dalam blok ini akan dijalankan secara automatik.
micro:bit mempunyai sensor akselerometer 3–paksi (x, y, z).
Sensor ini mengukur daya pergerakan pada semua arah.
Apabila jumlah daya yang dikesan mencapai >= 3g, blok ini akan aktif.
Blok ini sesuai digunakan dalam projek yang perlukan pengesan hentakan kuat, contohnya:
micro:bit diletakkan pada kotak.
Jika kotak dihentak / dialihkan kuat → bunyi alarm.
Jika micro:bit jatuh dan hentakannya kuat → paparkan amaran.
Jika berlaku hentakan kuat (kemalangan) → hantar mesej / LED SOS.
Goncangan kuat untuk “power move” dalam game.
Contoh:
on 3g
show leds heart
Interpretasi:
➡️ Bila micro:bit dikesan terkena daya kuat 3g, paparkan ikon hati.
👉 Blok “on 3g” ialah blok yang akan bertindak bila micro:bit terhentak atau digoncang kuat. Macam sensor pengesan hentakan. Bila sensor rasa pergerakan lebih 3g, arahan dalam blok akan dijalankan.
Blok ini adalah event block daripada kategori Input → Accelerometer dalam MakeCode micro:bit.
➡️ Blok ini akan menjalankan arahan di dalamnya apabila micro:bit mengesan daya hentakan atau pergerakan yang SANGAT KUAT, iaitu sekurang-kurangnya 6g.
“g” ialah unit gravitasi bumi (1g ≈ 9.8 m/s²)
6g bermaksud 6 kali g-force biasa
Ini adalah pergerakan yang sangat kuat, contohnya:
micro:bit terjatuh dari tinggi dan berhenti mengejut
micro:bit dipukul atau diketuk sangat kuat
micro:bit dilontar dan terkena hentakan besar
gegaran yang sangat kuat
👉 Pergerakan kecil, goyang biasa, atau goncang perlahan TIDAK akan mengaktifkan blok ini.
micro:bit mempunyai accelerometer 3-paksi (x, y, z).
Sensor ini mengukur daya pecutan dari semua arah.
Jika jumlah pecutan pada mana-mana paksi mencapai atau melebihi 6g, event ini akan trigger dan arahan dalam blok terus dijalankan.
Disebabkan 6g ialah pergerakan yang sangat kuat, blok ini sesuai untuk:
Jika micro:bit dalam helmet/basikal/kereta mainan menerima hentakan kuat → aktifkan mesej kecemasan.
Jika micro:bit jatuh dan menerima hentakan besar → paparkan alert.
Jika kotak, mesin, atau projek murid kena hentak kuat → alarm berbunyi.
Jika robot kena hentak luar biasa → motor berhenti untuk keselamatan.
Hanya bila pemain hentak dengan kuat → kuasa khas aktif.
on 6g
show leds sad
music.playTone(440, 200)
Maksud:
➡️ Bila micro:bit terkena hentakan SANGAT kuat (6g), LED paparkan muka sedih dan bunyi “beep” kedengaran.
👉 “on 6g” bermaksud: Apabila micro:bit menerima hentakan SUPER kuat (6 kali g-force), jalankan arahan dalam blok. Dia macam sensor pengesan hentakan besar.
Blok ini ialah event block (blok peristiwa) daripada kategori Input → Accelerometer dalam MakeCode.
Ia berfungsi untuk mengesan hentakan atau pergerakan yang sangat-sangat kuat pada micro:bit.
“g” = gravitational force (daya graviti)
1g ≈ 9.8 m/s²
8g = 8 kali g-force normal
👉 Ini adalah tahap hentakan yang sangat besar, lebih kuat daripada 3g atau 6g.
Micro:bit hanya akan aktifkan blok ini apabila menerima hentakan yang luar biasa kuat.
Contoh keadaan 8g:
micro:bit dijatuhkan dari ketinggian dan terhentak sangat kuat
micro:bit terkena pukulan keras
micro:bit dilanggar objek lain dalam eksperimen
pergerakan mengejut yang sangat ekstrem
➡️ Blok ini menjalankan kod di dalamnya apabila micro:bit mengesan daya hentakan ≥ 8g.
Ia digunakan untuk:
Untuk projek simulasi:
helmet
kenderaan robot
kotak keselamatan
Jika berlaku hentakan besar, micro:bit aktifkan amaran.
Hanya hentakan yang sangat kuat akan memulakan:
SOS alert
bunyi buzzer
mesej radio ke micro:bit lain
hantar mesej IoT
Jika robot jatuh, tergolek atau dilanggar kuat:
motor berhenti
lampu amaran menyala
Jika micro:bit mengalami hentakan luar biasa ketika mendarat.
Hanya hentakan kuat “super move” akan aktif — contohnya serangan kuasa.
micro:bit mempunyai accelerometer 3-paksi (X, Y, Z).
Sensor ini mengukur daya pecutan pada setiap arah.
Apabila gabungan daya paksi ini mencapai 8g atau lebih, blok “on 8g” akan trigger.
🚫 Goncangan biasa, jatuhan perlahan, atau hentakan kecil tidak cukup kuat untuk mengaktifkan blok ini.
on 8g
music.playTone(523, 200)
basic.showIcon(IconNames.Skull)
Maksud:
➡️ Jika micro:bit menerima hentakan sangat kuat (8g),
→ bunyi beep dimainkan
→ ikon tengkorak ditunjukkan sebagai “alert”.
👉 “on 8g” ialah blok yang bertindak bila micro:bit merasa hentakan SUPER kuat (8 kali graviti). Bila berlaku hentakan yang sangat besar, kod dalam blok akan dijalankan.
Blok ini ialah event block daripada kategori Input → Pins.
Ia digunakan untuk mengesan apabila Pin P0 disentuh atau ditekan (pressed).
Dalam micro:bit:
Pin P0 adalah salah satu pin input/output (I/O) di bahagian bawah micro:bit.
“pressed” bermaksud pin tersebut bersambung ke GND (ground) — seperti kita tekan suis.
micro:bit akan mengesan sentuhan atau sambungan wayar sebagai tekanan (press).
👉 Dalam bahasa mudah:
Apabila pin P0 disambungkan ke GND atau disentuh, arahan dalam blok akan dijalankan.
Pin boleh dianggap ditekan apabila:
Micro:bit membaca sentuhan jari sebagai sambungan (circuit closed).
Tekan butang → P0 bersambung ke GND → blok aktif.
Contohnya:
Big Cap Touch Sensor
Metal Touch Switch
Limit Switch
Pressure pad
Seperti klip buaya, foil, atau wayar lain.
➡️ Bila pin P0 dikesan ‘pressed’, kod dalam blok akan berjalan serta-merta.
Contoh:
on pin P0 pressed
basic.showIcon(IconNames.Heart)
Maksudnya:
➡️ Bila P0 ditekan, LED paparkan ikon hati.
Blok ini sangat penting dalam banyak projek fizikal micro:bit seperti:
Bina butang sendiri menggunakan klip buaya + aluminium foil.
Jadikan apa saja objek konduktif sebagai suis:
duit syiling
klip kertas
sudu besi
air (dalam eksperimen tertentu)
Jika butang disambungkan ke pintu/tingkap:
bila ditekan → alarm berbunyi.
Tekan butang → hantar mesej radio ke micro:bit lain.
P0 digunakan sebagai suis mula/berhenti robot.
P0 sebagai “Fire Button” atau “Jump Button”.
Digunakan untuk:
limit switch robot
sensor bump
magnetic reed switch
water level switch (ON/OFF)
micro:bit mengesan sambungan (circuit) seperti ini:
P0 ----> (tekan/bersentuh) ----> GND
Apabila pin P0 menjadi LOW (0) kerana bersentuhan dengan GND, event ini akan trigger.
👉 micro:bit tidak perlukan tenaga besar—sentuh dengan jari pun cukup sebab jari manusia konduktif.
👉 Blok “on pin P0 pressed” akan menjalankan arahan bila pin P0 disentuh atau disambung ke GND—seolah-olah kita tekan suis.
Blok ini ialah blok syarat (Boolean condition) yang digunakan untuk menyemak sama ada butang A pada micro:bit sedang ditekan pada saat itu.
Ia BUKAN blok event (macam “on button A pressed”)
— tetapi ia adalah blok pemeriksa keadaan (state checker).
➡️ Blok ini mengembalikan nilai TRUE atau FALSE.
TRUE → butang A sedang ditekan
FALSE → butang A tidak ditekan
Blok ini digunakan dalam:
If statements
While loops
Logic conditions
Input checking
on button A pressed
Event
Trigger sekali bila butang ditekan
button A is pressed
Condition
Sentiasa SEMAK jika butang sedang ditekan
➡️ “button A is pressed” membolehkan program sentiasa memerhati keadaan butang.
forever:
if button A is pressed:
show icon heart
else:
clear screen
Maksud:
LED hanya menyala semasa butang A ditekan.
if button A is pressed:
turn motor on
Motor hanya ON selagi butang A ditekan.
if button A is pressed:
shoot projectile
Blok ini sangat berguna dalam:
Tekan A → gerak ke depan
Lepas A → berhenti
tekan A untuk lompat
tekan lama untuk charging power
Tekan A → pilih item seterusnya
Servo bergerak hanya bila butang ditekan.
Button A bertindak sebagai suis input.
micro:bit mempunyai dua butang fizikal: A dan B.
Sensor butang akan membaca keadaan seperti berikut:
bila ditekan → signal LOW (0)
bila dilepas → signal HIGH (1)
Blok “button A is pressed” membaca nilai sensor ini dan memberikan output TRUE jika dalam keadaan LOW.
👉 “button A is pressed” ialah blok untuk memeriksa sama ada butang A sedang ditekan. Jika ditekan, outputnya TRUE. Jika tidak, outputnya FALSE.
Blok ini ialah blok sensor daripada kategori Input → Accelerometer.
Ia digunakan untuk membaca nilai pecutan (acceleration) yang dikesan oleh micro:bit pada paksi tertentu, dalam unit milli-gravity (mg).
“mg” = milli-gravity, iaitu seribu bahagian daripada 1g.
1g = daya graviti bumi ≈ 9.8 m/s²
1000 mg = 1g
Jadi nilai yang blok ini baca adalah dalam bentuk mg, seperti:
0 mg → tiada pecutan
1000 mg → 1g
-1000 mg → pecutan arah bertentangan
micro:bit mempunyai accelerometer 3 paksi:
x
kiri ↔ kanan (horizontal)
y
depan ↔ belakang (vertical tilt)
z
atas ↔ bawah (ketebalan/naik turun)
Dalam blok ini, cikgu boleh pilih:
x
y
z
👉 Pilihan ini menentukan paksi mana pecutan dibaca.
➡️ Blok ini memberikan nilai angka yang mewakili pecutan micro:bit pada paksi tertentu dalam unit mg.
Contoh:
Jika micro:bit digerakkan ke kanan dengan kuat:
acceleration (mg) x → 1500 mg
Jika micro:bit statik dan tidak bergerak:
x ≈ 0 mg (kadang-kadang ±10 mg kerana noise)
y ≈ 0 mg
z ≈ 1000 mg (sebab graviti)
Kosongkan skrin bila tiada gerakan, paparkan ikon bila gerakan kuat.
Gunakan nilai x dan y untuk mengetahui condong kiri/kanan atau depan/belakang.
Gerakkan sprite berdasarkan nilai pecutan paksi tertentu.
Paparkan nilai pecutan secara real-time.
Nilai x, y, z hampir 0 mg serentak → tanda micro:bit sedang jatuh.
Gunakan pecutan x/y sebagai input kawalan robot atau lengan mekanikal.
basic.forever(() => {
basic.showNumber(input.acceleration(Dimension.X))
})
if input.acceleration(Dimension.X) > 300:
show arrow right
Accelerometer micro:bit mengukur pecutan dalam tiga arah:
jika bergerak → nilai meningkat
jika berhenti → nilai kembali dekat 0 mg (kecuali paksi z yang sentiasa ≈ 1000 mg kerana graviti)
Nilai ini berubah sangat cepat, sesuai untuk projek seperti:
game controller
pengesan gegaran
pengesan kemalangan
robot balancing
👉 Blok “acceleration (mg) x” membaca berapa kuat micro:bit bergerak pada paksi x (kiri–kanan) dalam unit mg. Ia bagi kita nilai nombor supaya kita boleh buat game, pengesan gerakan, atau robot.
Blok ini ialah blok syarat (Boolean condition) daripada kategori Input → Pins.
Ia digunakan untuk menyemak sama ada pin P0 pada micro:bit sedang ditekan atau disambungkan ke GND pada saat itu.
Dalam micro:bit:
Pin P0 dianggap “pressed” bila ia bersambung ke GND
→ sama seperti menekan suis ON.
Ini boleh berlaku melalui:
jari kita (sentuhan — kerana jari konduktif)
klip buaya
push button
foil
sensor sentuhan
suis mekanikal
sensor air (ON/OFF)
mana-mana sambungan yang menyentuh GND
👉 Jika ada sambungan → nilai = TRUE
👉 Jika tiada sambungan → nilai = FALSE
Blok ini hanya membaca keadaan, bukan menjalankan event.
on pin P0 pressed
Event
Trigger SEKALI bila P0 disentuh
pin P0 is pressed
Condition
Sentiasa MENYEMAK jika P0 sedang disentuh
Makna penting:
➡️ Blok ini memberikan nilai TRUE atau FALSE berdasarkan keadaan pin P0.
Ia biasanya digunakan dalam:
If statements
Loop
Logik kawalan robot
Sensor keadaan (state detection)
Contoh:
if pin P0 is pressed:
show icon heart
pin P0 is pressed → TRUE
pin P0 is pressed → FALSE
Blok ini sangat berguna dalam projek seperti:
Gunakan push button antara P0 dan GND.
Sentuh pin P0 + GND → nilai TRUE.
Jika pintu tertutup → P0 bersambung → TRUE
Jika pintu dibuka → sambungan hilang → FALSE
P0 sebagai butang manual:
mula robot
berhenti robot
ubah mod robot
Jika air menghubungkan P0 dan GND → TRUE
(air = konduktor lemah)
Tekan pad logam → sambung ke GND → TRUE
micro:bit membaca voltan pada pin:
bila disentuh/sambung ke GND → voltan turun → dianggap “pressed”
bila terbuka → voltan naik → dianggap “not pressed”
Ini adalah konsep digital input.
👉 “pin P0 is pressed” memeriksa sama ada P0 sedang disentuh atau disambungkan ke GND. Jika ya → TRUE. Jika tidak → FALSE.
Ia macam kita tanya micro:bit:
“Adakah suis P0 ON sekarang?”
Blok “light level” ialah blok sensor daripada kategori Input dalam MakeCode.
Ia digunakan untuk mengukur kecerahan cahaya di sekeliling micro:bit.
➡️ Blok ini mengembalikan nilai angka (0 hingga 255) yang menunjukkan tahap cahaya yang diterima oleh micro:bit.
0 → gelap sepenuhnya
255 → sangat terang / cahaya maksimum
Nilai ini boleh digunakan dalam:
If statement
Loop
Projek automasi
Sistem penggera
Lampu automatik
micro:bit TIDAK mempunyai sensor cahaya khas.
Sebaliknya, ia menggunakan LED matrix 5x5 sebagai sensor cahaya.
Setiap LED boleh berfungsi dua cara:
Memancarkan cahaya (output)
Mengesan cahaya (input)
Sensor membaca jumlah cahaya yang memasuki LED, kemudian memberikan nilai 0–255.
✨ Inilah teknologi “reverse bias photo-sensing” pada LED.
Nilai berubah bergantung kepada:
jumlah cahaya dalam bilik
jarak micro:bit dengan sumber cahaya
arah micro:bit dihadapkan
halangan seperti tangan atau objek lain
Blok “light level” sering digunakan dalam projek seperti:
Jika gelap → hidupkan LED atau lampu luar.
Jika tangan menutup micro:bit → cahaya berkurang → trigger alarm.
Mengesan cahaya pantulan untuk mengetahui gelap/cerah.
Paparkan nilai cahaya dalam angka.
Kawalan game berdasarkan terang/gelap.
Mengesan isyarat lampu berkelip.
basic.forever(() => {
basic.showNumber(input.lightLevel())
})
if (input.lightLevel() < 50) {
basic.showIcon(IconNames.SmallDiamond)
}
if input.lightLevel() < 100:
turn on LED
else:
turn off LED
Gelap sangat
0–20
Bilik gelap
20–50
Pencahayaan biasa
60–150
Bilik terang
150–200
Cahaya lampu dekat / matahari
200–255
👉 “light level” membaca berapa terang atau gelap persekitaran micro:bit.
Nilainnya antara 0 (gelap) hingga 255 (sangat terang).
Blok “compass heading (°)” ialah blok sensor daripada kategori Input, digunakan untuk:
➡️ Membaca arah (heading) yang ditunjukkan oleh kompas digital micro:bit dalam unit darjah (°).
micro:bit mempunyai sensor magnetometer 3-paksi yang bertindak sebagai kompas.
Blok ini mengembalikan nilai 0° hingga 359°.
Nilai ini mewakili arah utara berdasarkan orientasi micro:bit.
Utara (North)
0°
Timur (East)
90°
Selatan (South)
180°
Barat (West)
270°
Antara nilai seperti:
45° = timur laut
135° = tenggara
225° = barat daya
315° = barat laut
micro:bit mempunyai magnetometer (sensor medan magnet) yang membaca:
medan magnet bumi
perubahan arah putaran micro:bit
gangguan dari magnet atau logam
Sensor ini mengukur kekuatan magnet dalam paksi:
X
Y
Z
Kemudian ia mengira arah utara dalam bentuk heading (°).
Apabila program pertama kali menggunakan kompas:
👉 micro:bit akan minta calibration (gerakkan micro:bit ikut corak titik).
Ini penting supaya bacaan arah lebih tepat.
Blok ini sangat berguna untuk projek:
Paparkan arah seperti:
N
E
S
W
Robot bergerak mengikut arah tertentu:
robot perlu berpusing ke 90°
halakan robot ke arah 180°
Game carian harta karun berdasarkan arah.
Mengesan magnet atau gangguan logam.
Arah micro:bit digunakan untuk kawalan:
pusing ke arah tertentu = action berubah
basic.forever(() => {
basic.showNumber(input.compassHeading())
})
if (input.compassHeading() < 45 || input.compassHeading() > 315) {
basic.showArrow(ArrowNames.North)
} else if (input.compassHeading() < 135) {
basic.showArrow(ArrowNames.East)
} else if (input.compassHeading() < 225) {
basic.showArrow(ArrowNames.South)
} else {
basic.showArrow(ArrowNames.West)
}
0° – 44°
Utara
45° – 134°
Timur
135° – 224°
Selatan
225° – 314°
Barat
315° – 359°
Utara (balik semula)
👉 “compass heading (°)” membaca arah kompas micro:bit dalam darjah 0–359. 0° ialah utara.
Blok “temperature (°C)” ialah blok sensor daripada kategori Input.
Ia digunakan untuk membaca suhu persekitaran (dalam darjah Celsius) berdasarkan sensor di dalam micro:bit.
micro:bit TIDAK mempunyai sensor suhu khas.
Sebaliknya, ia membaca suhu daripada mikropengawal (CPU / processor) micro:bit.
➡️ Suhu CPU berubah mengikut suhu persekitaran.
➡️ Oleh itu, bacaan suhu adalah anggaran, tetapi cukup tepat untuk projek pendidikan.
➡️ Blok ini mengembalikan nilai nombor dalam unit °C.
Contoh bacaan biasa:
20°C – 30°C → suhu bilik / suhu kelas
30°C – 40°C → micro:bit banyak menjalankan tugas / panas cuaca
< 15°C → kawasan sejuk / bilik berhawa dingin
40°C → panas luar biasa atau CPU bekerja keras
Bacaan suhu tidak 100% tepat, kerana dipengaruhi oleh:
haba dari litar micro:bit
cuaca persekitaran
angin atau aliran udara
penggunaan LED, radio, atau sensor lain
Namun ia tetap sesuai untuk:
eksperimen sains
projek STEM
automasi asas
sistem penggera
Blok “temperature (°C)” digunakan dalam:
Paparkan suhu secara langsung di LED.
Jika suhu > 35°C → bunyi alarm.
Jika suhu panas → hidupkan kipas (servo/motor).
Pantau suhu bilik / suhu dalam kotak.
Hantar data suhu ke komputer / Thingspeak / dashboard IoT.
Gabungkan dengan sensor cahaya + kompas.
basic.forever(() => {
basic.showNumber(input.temperature())
})
if (input.temperature() > 32) {
basic.showIcon(IconNames.Asleep)
}
if (input.temperature() > 30) {
pins.digitalWritePin(DigitalPin.P1, 1)
} else {
pins.digitalWritePin(DigitalPin.P1, 0)
}
0°C – 10°C
Sejuk sangat
15°C – 25°C
Suhu bilik
25°C – 35°C
Biasa/panas
35°C – 45°C
Panas tinggi
> 45°C
CPU panas / persekitaran ekstrem
👉 “temperature (°C)” memberi bacaan suhu dalam darjah Celsius. micro:bit baca suhu CPU sebagai anggaran suhu sekeliling.
Blok ini ialah blok syarat (Boolean condition) daripada kategori Input → Gesture.
Ia digunakan untuk memeriksa sama ada micro:bit sedang melakukan gerakan tertentu, bergantung kepada pilihan dalam menu:
shake
tilt left
tilt right
tilt up
tilt down
face up
face down
free fall
3g / 6g / 8g
logo up / logo down
… dan lain-lain.
Default dalam blok cikgu ialah shake (goncang).
➡️ Blok ini memeriksa keadaan real-time dan akan mengembalikan:
TRUE → jika micro:bit sedang melakukan gesture tersebut
FALSE → jika micro:bit tidak melakukan gesture itu
Ia tidak “trigger” sekali sahaja.
Ia sentiasa membaca keadaan accelerometer.
micro:bit mempunyai accelerometer 3-paksi:
X (kiri ↔ kanan)
Y (atas ↔ bawah)
Z (hadap atas ↔ hadap bawah)
Apabila micro:bit digoncang atau digerakkan, nilai pecutan berubah.
micro:bit akan:
membaca pecutan
memadan perubahan itu dengan corak tertentu
menentukan gesture yang sedang berlaku
Contohnya:
shake → pecutan berubah cepat & rawak
tilt left → nilai X berubah ke arah tertentu
free fall → hampir tiada pecutan (0g)
face up → Z paksi ≈ +1g
logo up → micro:bit menghadap ke atas
Blok ini digunakan dalam projek seperti:
goncang → dapat power
tilt → gerakkan karakter kiri/kanan
free fall → mode kecemasan
shake → penggera anti-kecurian
free fall → pengesan jatuh
tilt kiri → robot belok kiri
tilt kanan → robot belok kanan
shake → robot berhenti
goncang → tukar mode
face up → tunjuk maklumat
face down → tidur / pause
if (input.isGesture(Gesture.Shake)) {
basic.showIcon(IconNames.Heart)
}
if (input.isGesture(Gesture.TiltLeft)) {
moveLeft()
}
if (input.isGesture(Gesture.TiltRight)) {
moveRight()
}
if (input.isGesture(Gesture.Shake)) {
music.playTone(523, 500)
}
if (input.isGesture(Gesture.FreeFall)) {
basic.showString("FALL!")
}
on shake
Event
Trigger sekali bila shake berlaku
is shake gesture
Condition
Sentiasa periksa jika sedang shake
👉 “is shake gesture” memeriksa sama ada micro:bit sedang digoncang sekarang. Jika ya → TRUE, jika tidak → FALSE.
Ia sangat sesuai untuk permainan dan kawalan gesture.
Blok ini ialah event block (blok peristiwa) daripada kategori
Input → Sound (hanya ada pada micro:bit V2 yang mempunyai built-in microphone).
Fungsi utamanya:
➡️ Menjalankan kod apabila micro:bit mengesan bunyi kuat (loud sound).
“Loud sound” merujuk kepada bacaan bunyi yang melepasi tahap tertentu (threshold).
Contohnya:
tepukan tangan kuat
jeritan
bunyi pintu ditutup kuat
ketukan meja
muzik yang kuat
persekitaran yang bising
micro:bit membaca tahap bunyi melalui sensor mikrofon dan mengaktifkan event ini bila bunyi cukup kuat.
Micro:bit V2 mempunyai:
microphone MEMS kecil
sound level meter terbina dalam
LED indikator mikrofon (ikon mikrofon menyala bila bunyi dikesan)
Apabila mikrofon menerima getaran bunyi:
ia menukar gelombang bunyi kepada isyarat elektrik
micro:bit menganalisis kekuatan bunyi
jika melebihi tahap “loud”, event akan diaktifkan
Blok ini menyatakan:
➡️ “Apabila micro:bit mengesan bunyi kuat, jalankan arahan dalam blok ini.”
Ia berfungsi sama seperti:
on button A pressed → bila butang ditekan
on shake → bila digoncang
on loud sound → bila bunyi kuat berlaku
Blok ini sangat berguna untuk projek seperti:
Tepuk tangan → lampu LED hidup atau bertukar.
Jika bilik bising → micro:bit bunyikan siren.
Jika kelas terlalu bising → micro:bit paparkan amaran.
Tepuk → lompat
Jerit → tembak
Bunyi kuat → aktifkan kuasa
Kira berapa kali murid tepuk tangan.
Tepuk = bergerak
Dua tepukan = berhenti
on loud sound
show icon (happy)
on loud sound
pins.digitalWritePin(P1, 1)
on loud sound
music.playTone(523, 200)
micro:bit membezakan 2 event bunyi:
quiet sound (bunyi persekitaran rendah)
loud sound (bunyi melebihi ambang tertentu)
Cikgu boleh ubah sensitiviti bunyi menggunakan:
set loud sound threshold to (value)
👉 “on loud sound” akan aktif bila micro:bit dengar bunyi kuat. Bila bunyi kuat berlaku, micro:bit jalankan arahan dalam blok itu.
Ia macam sensor tepuk atau sensor bunyi.
Blok ini ialah event block (blok peristiwa) di bawah kategori:
➡️ Input → Sound (KHAS untuk micro:bit V2 yang ada mikrofon terbina).
Fungsi utama:
➡️ Menjalankan kod apabila micro:bit mengesan suasana menjadi senyap / bunyi rendah (quiet).
“Quiet sound” bermaksud tahap bunyi yang rendah, di bawah ambang (threshold) tertentu.
Situasi bunyi “quiet” termasuk:
bilik sunyi
tiada perbualan / murid diam
tiada tapak kaki atau bunyi objek
suara perlahan
mikrofon tidak menerima bunyi signifikan
micro:bit menganalisis kekuatan gelombang bunyi.
Jika bunyi turun menjadi rendah → event “on quiet sound” akan aktif.
micro:bit V2 mempunyai:
microphone MEMS
sound level meter
LED indikator mikrofon
Ia mengukur amplitud bunyi, bukan jenis bunyi.
Proses:
mikrofon menangkap getaran bunyi
micro:bit menukarnya kepada isyarat digital
sistem menentukan sama ada bunyi “quiet” atau “loud”
jika bunyi rendah → event “on quiet sound” triggered
➡️ Apabila keadaan sekeliling menjadi sunyi, kod dalam blok akan dijalankan.
Contoh:
Bila kelas sunyi → tunjuk ikon “thumbs up”
Bila robot tidak menerima bunyi → berhenti bergerak
Bila tepukan berhenti → tukar mod permainan
Blok “on quiet sound” sesuai digunakan untuk projek seperti:
Jika kelas sunyi → micro:bit paparkan ⭐ “Good job”.
Jika bunyi berhenti → micro:bit kira masa senyap.
Gunakan “quiet” sebagai trigger:
jika pemain senyap → dapat markah
jika bunyi → kalah
Robot hanya gerak bila bunyi → robot berhenti bila senyap.
Kesunyian berpanjangan → micro:bit aktifkan fungsi lain
(sesuai untuk bilik tidur / perpustakaan mini)
Bunyi → lampu hidup
Senyap → lampu padam
on quiet sound
basic.showIcon(IconNames.Happy)
on quiet sound
basic.showString("Good!")
on quiet sound
motors.stop()
Cikgu juga boleh mengubah ambang menggunakan:
set sound threshold
threshold rendah → mudah trigger
threshold tinggi → perlu lebih senyap
on loud sound
Bunyi kuat / bising
on quiet sound
Suasana senyap / bunyi rendah
Kedua-duanya event tetapi bertindak berlawanan.
👉 “on quiet sound” akan aktif bila persekitaran senyap. Bila suasana sunyi, arahan dalam blok akan dijalankan.
Ia macam sensor sunyi / sensor ketenangan.
Blok ini ialah event block (blok peristiwa) daripada kategori Input.
Ia KHAS untuk micro:bit V2, kerana hanya versi ini yang mempunyai sensor sentuhan kapasitif pada bahagian logo micro:bit.
Fungsi utama:
➡️ Menjalankan arahan apabila logo micro:bit disentuh atau ditekan.
Pada micro:bit V2:
Bahagian logo emas (di atas LED matrix)
Ada sensor capacitive touch
Ia boleh merasakan sentuhan jari manusia seperti:
tekan
sentuh
pegang
ketuk ringan
Logo itu bertindak sebagai butang sentuhan digital (touch button).
➡️ Bila logo disentuh → blok ini akan trigger sekali.
Ia sama konsep seperti:
on button A pressed
on pin P0 pressed
Tetapi versi ini ialah:
Sensor sentuh kapasitif berfungsi dengan:
Membaca perubahan kapasitans (muatan elektrik kecil) pada plat sentuh.
Apabila jari menyentuh logo, kapasitans meningkat.
micro:bit mengesan perubahan dan mengaktifkan event pressed.
Ia TIDAK memerlukan tekanan — cukup sekadar sentuhan lembut.
Dalam MakeCode, cikgu boleh pilih:
pressed → bila disentuh sekali
released → bila jari dilepaskan
long pressed → bila sentuh lama
Blok ini sangat berguna untuk:
Logo sebagai butang ON/OFF.
Tekan logo → menu seterusnya.
Tekan logo → mula/berhenti robot.
Logo sebagai “fire button” atau “power button”.
Sentuhan logo → aktifkan alarm.
Logo sebagai input nota bunyi.
Boleh digunakan seperti sensor “tap”.
on logo pressed
basic.showIcon(IconNames.Heart)
on logo pressed
motor_on = !motor_on
on logo pressed
music.playTone(262, 500)
LOGO - Tidak perlu wayar
PIN - Perlu GND + wayar
LOGO - Sentuhan kapasitif
PIN - Sentuhan konduktif
LOGO - Micro:bit V2 sahaja
PIN - Semua versi
LOGO - Sentuhan ringan sudah cukup
PIN - Perlu sambungan lengkap
👉 “on logo pressed” ialah blok yang akan jalankan arahan bila kita menyentuh logo micro:bit. Logo micro:bit V2 ada sensor sentuhan macam butang.
Blok ini ialah event block (blok peristiwa) daripada kategori Input, dan ia hanya terdapat pada micro:bit V2 yang mempunyai logo capacitive touch sensor.
Fungsinya:
➡️ Menjalankan kod apabila logo micro:bit disentuh (touched).
“Touched” bermaksud:
jari menyentuh logo micro:bit
tidak perlu tekanan
sentuhan ringan pun sudah cukup
tidak perlu sambungan GND seperti pin P0
sekadar menyentuh permukaan logo emas
Logo micro:bit adalah plat sentuh kapasitif yang mengesan perubahan elektrik kecil apabila disentuh.
micro:bit V2 mempunyai sensor kapasitif pada logo.
Cara ia berfungsi:
Jari manusia mempunyai cas elektrik semula jadi.
Bila jari menyentuh logo mikro:bit, kapasitans berubah.
micro:bit mengesan perubahan ini.
Event “on logo touched” diaktifkan.
Ia sama seperti teknologi touch screen pada telefon pintar tetapi lebih ringkas.
Dalam menu pilihan blok ini, ada:
pressed
touched
released
long pressed
Perbezaannya:
touched
Diaktifkan SEBAIK sahaja jari menyentuh logo
pressed
Diaktifkan bila sentuhan lebih kukuh / stabil
released
Diaktifkan bila jari dilepaskan
long pressed
Diaktifkan bila sentuh selama beberapa saat
“touched” ialah event paling sensitif — sentuhan sekejap pun diterima.
Blok ini berguna untuk:
Sentuh logo → ON, sentuh lagi → OFF.
Sentuh → bunyi nota.
Sentuh logo → ke menu seterusnya.
Sentuh → tembak peluru
Sentuh → lompat
Sentuh → power-up
Sentuh → mula bergerak
Sentuh lama → berhenti
Buat papan maklum balas:
“Sentuh logo jika awak faham!”
Logo sebagai “sensor tapak jari”.
on logo touched
basic.showIcon(IconNames.Heart)
on logo touched
music.playTone(262, 200)
on logo touched
lampu = !lampu
on logo touched
mode = mode + 1
Tidak perlukan wayar atau pin
Tidak perlukan GND
Lebih sensitif daripada pin P0
Selesa digunakan oleh murid tahun 6
Sangat sesuai untuk projek interaktif
👉 “on logo touched” akan aktif apabila kita menyentuh logo micro:bit. Sensor sentuhan logo berfungsi seperti butang sentuh.
Blok ini ialah event block (blok peristiwa) daripada kategori Input, khusus untuk micro:bit V2 yang mempunyai sensor sentuhan kapasitif pada bahagian logo.
Fungsinya:
➡️ Menjalankan arahan apabila logo micro:bit dilepaskan selepas disentuh.
“Released” ialah peristiwa yang berlaku SELEPAS kita melepaskan jari daripada logo.
Proses lengkapnya:
Jari menyentuh logo → (touched / pressed event)
Jari kekal di logo → (long pressed event)
Jari dilepaskan → released event berlaku
Event ini dipanggil SEKALI SAHAJA, iaitu tepat ketika jari dilepaskan.
Logo micro:bit V2 mempunyai capacitive touch sensor.
Ia mengesan sentuhan berdasarkan perubahan kapasitans (muatan elektrik).
Semasa sentuh → kapasitans naik
Semasa dilepas → kapasitans turun
micro:bit mengesan perubahan menurun ini sebagai “released”
touched
Berlaku SEBAIK sahaja jari menyentuh logo
pressed
Berlaku apabila sentuhan lebih stabil / kuat
released
Berlaku apabila jari dilepaskan dari logo
“released” = event selepas sentuh selesai.
Blok “on logo released” sangat berguna dalam projek seperti:
Lepas sentuh → ON
Lepas sentuh lagi → OFF
Sentuh → tahan bunyi
Released → berhenti bunyi
Sentuh = bersedia
Released = tembak peluru
Sentuh & tahan = robot charging power
Released = robot bergerak
Sentuh logo → mula
Released → berhenti
Sentuh ringan → released → efek tertentu
on logo released
basic.showIcon(IconNames.Heart)
on logo released
music.stopAllSounds()
on logo released
lampu = !lampu
on logo pressed
power += 1
on logo released
shoot(power)
power = 0
Sensor logo micro:bit sangat sensitif kepada:
sentuhan jari
kelembapan
cas statik
pergerakan jari
Ia bekerja seperti touch button pada telefon.
👉 “on logo released” akan aktif bila kita lepaskan jari daripada logo micro:bit. Ia digunakan bila kita nak buat fungsi selepas sentuhan tamat.
Blok ini ialah event block (blok peristiwa) daripada kategori Input, khusus untuk micro:bit V2 yang mempunyai sensor sentuhan kapasitif pada logo.
Fungsinya:
➡️ Menjalankan arahan apabila logo micro:bit disentuh dan dipegang lama (long press).
“Long pressed” berlaku apabila:
Jari menyentuh logo
Jari tidak dilepaskan
micro:bit mengesan durasi sentuhan melepasi masa tertentu (±500ms–1000ms)
👉 Hanya akan trigger apabila jari ditahan cukup lama.
Ia tidak sama dengan:
touched → sentuh sekejap
pressed → sentuhan stabil
released → jari dilepaskan
long pressed → jari tahan lama
Logo micro:bit V2 ialah sensor kapasitif.
Ia:
mengesan kehadiran jari (kapasitans naik)
mengukur berapa lama sentuhan kekal
jika lebih lama daripada threshold → event “long pressed” dihantar
micro:bit mengesan perubahan elektrik secara berterusan semasa jari menyentuh logo.
“Long press” digunakan apabila projek memerlukan tindakan khas atau tambahan, contohnya:
tekan lama → buka menu
tekan lama → reset nilai
tekan lama → mode lain
tekan lama → aktifkan ciri keselamatan
tekan lama → fungsi “charging power”
Sentuh biasa → next
Tekan lama → back atau confirm
Tekan sekejap = berhenti
Tekan lama = robot mula berjalan
Tekan lama = naikkan kuasa
Lepaskan = tembak kuat
Tekan lama → naikkan kelajuan/brightness
Tekan lama → clear score / reset game
Tekan lama → aktifkan alarm SOS
on logo long pressed
basic.showIcon(IconNames.Skull)
on logo long pressed
mode = 1
on logo pressed
power += 1
on logo long pressed
basic.showString("MAX!")
on logo long pressed
pins.digitalWritePin(P1, 0)
touched
Sentuh sekejap, ringan
pressed
Sentuhan lebih stabil
long pressed
Sentuhan lama (tahan)
released
Jari dilepaskan
Long press = paling lambat berlaku, sebab tunggu durasi sentuhan.
👉 “on logo long pressed” akan aktif bila kita sentuh logo micro:bit dan tahan lama. Ia digunakan untuk fungsi khas seperti power-up, reset, menu atau mod rahsia.
Blok ini ialah blok syarat (Boolean condition) dalam kategori Input, khusus untuk micro:bit V2.
Fungsinya:
➡️ Menyemak (check) sama ada logo micro:bit sedang ditekan/dipersentuh pada saat itu.
➡️ Mengembalikan nilai TRUE atau FALSE.
Ia bukan event, tetapi state checker.
micro:bit V2 mempunyai sensor sentuh kapasitif di bahagian logo.
“logo is pressed” bermaksud:
jari sedang menyentuh logo
sentuhan kekal dan stabil
bukan sekadar sentuh sekejap (itu “touched”)
bukan sentuh sangat lama (itu “long pressed”)
👉 “pressed” = sentuhan aktif semasa kod sedang berjalan.
Blok ini memberi:
Jika logo sedang disentuh sekarang.
Jika logo tidak disentuh.
Ia boleh digunakan dalam:
if statements
while loops
logic blocks
control structures
Logo micro:bit ialah sensor kapasitif yang:
Mengesan kehadiran jari
Mengukur perubahan kapasitans
Semak jika sentuhan kekal
Jika Ya → nilai TRUE
Sensor kapasitif sangat sensitif, jadi tak perlu tekan kuat — sentuh lembut pun cukup.
Blok ini bagus untuk projek yang memerlukan tindak balas berterusan semasa sentuhan berlaku.
Logo sebagai butang ON semasa disentuh.
Jika logo ditekan → lampu menyala
Jika dilepas → lampu padam
Semasa logo ditekan → pemain charge power
Semasa dilepas → power dilepaskan
Sentuh logo = robot bergerak
Lepas logo = robot berhenti
Tahan logo = bunyi berterusan
Lepas = bunyi berhenti
Logo digunakan seperti sensor tekanan digital.
if (input.logoIsPressed()) {
basic.showIcon(IconNames.Heart)
} else {
basic.clearScreen()
}
if (input.logoIsPressed()) {
music.playTone(262, 100)
}
if (input.logoIsPressed()) {
motors.forward(50)
} else {
motors.stop()
}
if (input.logoIsPressed()) {
power += 1
}
(Combine dengan released event untuk tembak power)
on logo pressed
Event
Trigger SEKALI bila logo disentuh
logo is pressed
Condition
Sentiasa semak kalau logo sedang disentuh
“logo is pressed” = tahan/sentuh sekarang
“on logo pressed” = sentuh sahaja
👉 “logo is pressed” memeriksa sama ada logo micro:bit sedang disentuh pada masa itu. Jika ya, TRUE. Jika tidak, FALSE.
Ia macam kita tanya micro:bit:
“Logo tu tengah ditekan ke sekarang?”
Blok “sound level” ialah blok sensor dalam kategori Input, khas untuk micro:bit V2 (yang ada mikrofon terbina).
Fungsinya:
➡️ Membaca tahap bunyi (sound intensity) yang ditangkap oleh mikrofon micro:bit dalam bentuk nombor.
Blok ini mengembalikan nilai antara 0 hingga 255.
→ sangat senyap (tiada bunyi)
→ persekitaran tenang (bunyi perlahan / suara rendah)
→ suara kuat, tepukan ringan, bunyi objek jatuh
→ bunyi sangat kuat / bising (jeritan, muzik kuat, tepukan kuat)
Nilai berubah setiap saat berdasarkan keadaan bunyi.
micro:bit V2 mempunyai:
MEMS microphone sensitif
sound level meter
LED indikator mikrofon
Cara ia bekerja:
Mikrofon menangkap getaran bunyi
Gelombang bunyi ditukar kepada isyarat elektrik
Micro:bit mengukur amplitud bunyi
Bacaan dikeluarkan sebagai nombor 0–255
Tiada pengesanan jenis bunyi, hanya kekuatan bunyi.
➡️ Blok ini digunakan untuk memantau bunyi secara berterusan.
Ia boleh digunakan dalam:
if statements
graphing
penggera
game control
pengesan bising bilik
Blok ini sangat berguna untuk projek seperti:
Paparkan bunyi seperti meter decibel mini.
Jika bilik terlalu bising → tunjuk ikon marah / beri amaran.
Jika nilai bunyi > 200 → lampu hidup.
Jerit = lompat
Bunyi kuat = tembak peluru
Tepuk tangan → robot bergerak.
Bunyi kuat = alarm berbunyi.
Rekod perubahan bunyi sepanjang masa untuk projek sains.
basic.forever(function () {
basic.showNumber(input.soundLevel())
})
if (input.soundLevel() > 150) {
basic.showIcon(IconNames.Surprised)
}
if (input.soundLevel() > 200) {
lampu = !lampu
}
if (input.soundLevel() > 180) {
music.playTone(523, 200)
}
0–20
Sunyi sangat
20–80
Bilik normal
80–150
Sedikit bising
150–200
Tepukan / suara kuat
200–255
Bunyi sangat kuat
👉 “sound level” membaca tahap bunyi sekeliling dalam bentuk nombor 0–255. Lagi kuat bunyi, lagi tinggi nombor.
Blok ini digunakan untuk:
Menjalankan proses penentukuran (calibration) sensor kompas / magnetometer micro:bit supaya bacaan arah (0°–359°) jadi lebih tepat.
Tanpa calibration, bacaan compass heading (°) boleh lari jauh – kadang-kadang “Utara” micro:bit bukan utara sebenar.
Apabila program sampai kepada blok calibrate compass:
Program berhenti sekejap dan masuk ke mod calibration.
Di skrin LED micro:bit akan keluar arahan (biasanya titik bergerak).
Pengguna diminta menggerakkan micro:bit dalam pelbagai arah (pusing, goncang, buat bulatan “figure-8”) supaya sensor magnetometer:
mengenal pasti gangguan magnet sekeliling,
mengukur medan magnet bumi dari semua sudut.
Bila cukup data dikumpul, micro:bit akan:
simpan nilai pembetulan (offset),
tamatkan proses calibration,
sambung semula program selepas blok itu.
Proses ini hanya perlu sekali setiap kali micro:bit di-reset / program baru dimuat naik (selagi tak tukar persekitaran magnet terlalu banyak).
Magnetometer micro:bit sangat sensitif. Bacaan boleh dipengaruhi oleh:
objek besi / magnet berhampiran (meja besi, kipas, speaker),
wayar kuasa, motor atau magnet lain,
cara kita memegang micro:bit.
Calibration membantu:
“ajar” micro:bit apa itu medan magnet bumi yang sebenar,
bezakan antara magnet bumi dan gangguan sekeliling,
betulkan bacaan arah compass heading (°) supaya:
0° ≈ Utara,
90° ≈ Timur,
180° ≈ Selatan,
270° ≈ Barat.
Letakkan calibrate compass di tempat yang logik dalam projek, contohnya:
input.onButtonPressed(Button.A, function () {
input.calibrateCompass()
})
Atau di awal program (sekali sahaja):
basic.showString("Hi")
input.calibrateCompass()
Guna blok ini jika projek cikgu melibatkan:
kompas digital (tunjuk N, E, S, W),
robot bergerak ikut arah (pusing ke 90°, 180° dll),
projek carian harta karun guna arah,
apa-apa projek yang guna blok compass heading (°).
Semasa calibration:
Jauhkan micro:bit daripada:
magnet,
motor,
wayar kuasa besar,
permukaan besi.
Gerakkan micro:bit perlahan dan menyeluruh (pusing ikut semua sudut).
Jangan sentuh butang lain sehingga siap.
👉 Blok calibrate compass ialah blok untuk “set semula” dan betulkan kompas micro:bit.
Bila blok ini dijalankan, micro:bit suruh kita pusingkannya ke semua arah supaya dia boleh baca medan magnet bumi dengan tepat. Lepas siap, bacaan arah kompas jadi lebih betul.
Blok ini adalah blok sensor dalam kategori Input, digunakan untuk membaca kekuatan medan magnet yang dikesan oleh magnetometer 3-paksi micro:bit.
µT (microtesla) ialah unit ukuran medan magnet.
➡️ Blok ini mengembalikan nilai kekuatan medan magnet pada salah satu paksi:
X
Y
Z
Nilai ini datang daripada sensor magnetometer (kompas) micro:bit.
Cikgu boleh pilih pakej paksi pada menu drop-down.
Magnetometer micro:bit mengukur medan magnet dalam 3 arah:
Kiri ↔ Kanan
Atas ↔ Bawah
Depan ↔ Belakang (keluar-masuk dari permukaan micro:bit)
Setiap paksi mengembalikan nilai berbeza kerana medan magnet datang dari pelbagai arah.
Sensor magnet micro:bit mengesan:
medan magnet bumi (untuk kompas),
gangguan magnet dari objek besi,
magnet bar,
motor DC,
wayar kuasa,
speaker,
peralatan elektrik.
Dengan membaca setiap paksi secara berasingan, kita boleh:
tahu arah sumber medan magnet,
mengukur kekuatan magnet,
mengesan pergerakan magnet dalam 3D.
Nilai tipikal:
Tiada magnet berhampiran
20 – 70 µT (medan magnet bumi)
Ada magnet lemah
100 – 200 µT
Magnet kuat dekat sensor
300 – 1000+ µT
Motor / besi besar
berubah secara rawak
Nilai boleh jadi positif atau negatif bergantung kepada arah medan magnet.
Blok ini TIDAK menunjukkan arah kompas secara langsung.
Ia membaca nilai mentah (raw data) daripada magnetometer.
Kompas (heading) menggunakan gabungan X, Y dan Z → untuk tentukan utara.
Blok ini sangat berguna untuk:
Micro:bit berbunyi bila magnet dekat.
Letakkan magnet pada pintu.
Pintu rapat → magnet dekat → nilai tinggi
Pintu buka → tiada magnet → nilai rendah
Motor menghasilkan medan magnet → nilai berubah.
Besi dan keluli sebabkan gangguan medan magnet.
Gunakan bacaan X, Y untuk sistem kompas 3D.
Buat graf medan magnet terhadap jarak.
basic.forever(function () {
basic.showNumber(input.magneticForce(Dimension.X))
})
if (input.magneticForce(Dimension.X) > 200) {
basic.showIcon(IconNames.Yes)
} else {
basic.showIcon(IconNames.No)
}
if (input.magneticForce(Dimension.Y) > 150) {
// pintu rapat
pins.digitalWritePin(DigitalPin.P1, 1)
} else {
// pintu terbuka
pins.digitalWritePin(DigitalPin.P1, 0)
}
👉 Blok “magnetic force (µT)” membaca kekuatan medan magnet di sekeliling micro:bit. Nilainya dalam bentuk microtesla (µT) dan boleh digunakan untuk mengesan magnet, pintu, motor dan gangguan magnet lain.
Blok rotation (°) digunakan untuk membaca sudut kecondongan (tilt angle) micro:bit dalam unit darjah (°) berdasarkan bacaan daripada accelerometer.
Dalam menu dropdown, ada 3 pilihan:
Pitch
Roll
Yaw (bergantung pada versi MakeCode)
Dalam gambar cikgu → Pitch dipilih.
Pitch ialah nilai kecondongan ke depan ↔ ke belakang.
Bayangkan micro:bit macam kepala kita:
Tunduk ke depan = pitch bertambah
Dongak ke belakang = pitch berkurang
Atau macam pesawat:
Hidung kapal terbang turun → pitch negatif
Hidung kapal terbang naik → pitch positif
Biasanya pitch berada dalam julat:
–90° → micro:bit condong penuh ke depan
0° → micro:bit rata & mendatar
+90° → micro:bit condong penuh ke belakang
Dalam sesetengah keadaan nilai boleh lebih sedikit (hingga ±180° bergantung kepada cara bacaan accelerometer).
Micro:bit memiliki accelerometer 3-paksi:
X → kiri ↔ kanan
Y → atas ↔ bawah
Z → depan ↔ belakang
Dengan membaca vektor pecutan graviti pada paksi-paksi ini, micro:bit mengira sudut orientasi (rotation angle).
Formula asas (dipermudahkan):
pitch = atan2(X, sqrt(Y² + Z²))
Ringkasnya:
Micro:bit melihat “arah graviti” untuk tahu ia condong ke mana.
Blok rotation (pitch) boleh digunakan dalam:
Tunduk → watak jalan ke depan
Dongak → watak berhenti / lompat
Micro:bit dipegang sebagai “remote controller”.
Ukur sudut permukaan meja / platform.
Mengukur sudut condong atau graviti.
Sudut pitch → sudut servo.
Jika pitch berubah secara mendadak → bunyi alarm.
basic.forever(function () {
basic.showNumber(input.rotation(Rotation.Pitch))
})
if (input.rotation(Rotation.Pitch) < -30) {
basic.showArrow(ArrowNames.North)
}
if (input.rotation(Rotation.Pitch) > 30) {
basic.showArrow(ArrowNames.South)
}
if (input.rotation(Rotation.Pitch) < -20) {
forward()
}
else if (input.rotation(Rotation.Pitch) > 20) {
backward()
}
Pitch
Depan ↔ Belakang
Tunduk / dongak
Roll
Kiri ↔ Kanan
Condong ke tepi
Yaw
Putar kiri ↔ kanan (kompas)
Pusing macam stereng
Pitch fokus pada kecondongan depan-belakang.
👉 rotation (pitch) membaca berapa banyak micro:bit condong ke depan atau ke belakang dalam unit darjah (°). Kalau tunduk ke depan, nilai negatif. Kalau dongak ke belakang, nilai positif.
Blok ini digunakan untuk:
➡️ Mendapatkan jumlah masa (dalam milisaat / ms) sejak program micro:bit mula berjalan.
Ia mengembalikan nilai integer (nombor).
ms = milisaat
1 saat = 1000 ms
Jadi, jika running time = 5000 ms, maksudnya program sudah berjalan selama 5 saat.
Blok running time (ms) membaca:
✔️ masa sejak power on, atau
✔️ masa sejak program dimulakan semula, seperti:
reset micro:bit
download program baru
restart power supply
Ia TIDAK berhenti, terus meningkat selagi micro:bit hidup.
Running time digunakan untuk:
Contohnya:
tempoh sentuhan
tempoh murid menyelesaikan permainan
timer untuk robot bergerak
Bezakan masa mula dan masa tamat.
Digunakan dalam coding:
pergerakan animasi
kawalan motor servo
masa antara dua peristiwa
Jadi sumber masa untuk:
countdown
delay custom
animasi LED lebih smooth
Contoh:
baca masa bila logo disentuh
baca masa bunyi kuat berlaku
Contoh bacaan semasa micro:bit berjalan:
1 saat
1000
5 saat
5000
30 saat
30000
1 minit
60000
10 minit
600000
Nilai boleh mencapai jutaan milisaat jika micro:bit dibiarkan lama.
basic.forever(function () {
basic.showNumber(input.runningTime())
})
let mula = input.runningTime()
// selepas beberapa aktiviti
let tamat = input.runningTime()
let duration = tamat - mula
basic.showNumber(duration)
let lastTime = 0
basic.forever(function () {
if (input.runningTime() - lastTime > 200) {
led.toggle(2, 2)
lastTime = input.runningTime()
}
})
Robot bergerak 3 saat:
let start = input.runningTime()
motors.forward(50)
basic.forever(function () {
if (input.runningTime() - start > 3000) {
motors.stop()
}
})
Ia hanya mengukur masa program berjalan, bukan masa dunia sebenar.
Ia hanya reset bila micro:bit restart atau flash program baru.
👉 running time (ms) beri kita masa (dalam milisaat) sejak program micro:bit mula berjalan. Kita boleh guna untuk stopwatch, timer, animasi, dan kawalan robot.
Blok ini digunakan untuk:
➡️ Membaca jumlah masa (dalam unit mikro-saat — microseconds) sejak program micro:bit mula berjalan.
Ia sama seperti running time (ms) tetapi dengan ketepatan yang jauh lebih tinggi.
micros = microseconds
1 microsecond = 1 / 1,000,000 saat
1 milisecond (ms) = 1000 microseconds (µs)
Jadi:
Unit
Nilai
1 s
1,000 ms
1 ms
1,000 µs
1 s
1,000,000 µs
Blok ini mengembalikan nombor integer yang sangat besar kerana ia terus meningkat dari 0 → jutaan → ratusan juta selepas beberapa minit.
Contoh bacaan:
Masa berjalan
running time (micros)
1 ms
1,000 µs
100 ms
100,000 µs
1 saat
1,000,000 µs
10 saat
10,000,000 µs
Blok ini sangat berguna untuk projek yang memerlukan masa yang sangat tepat, seperti:
Ultrasonic HC-SR04 mengira jarak berdasarkan masa balik echo dalam microseconds.
Contoh:
kelajuan motor
kelajuan objek jatuh
kelajuan pusingan roda robot
Digunakan untuk:
isyarat PWM
IR receiver
analisis getaran
menilai durasi denyutan elektrik
Untuk projek eksperimen:
masa tindak balas
perubahan suhu cepat
graf perubahan nilai sensor
Jika mahu animasi LED dengan smooth transition atau variasi pergerakan yang konsisten pada kadar micro-second.
basic.forever(function () {
basic.showNumber(input.runningTimeMicros())
})
let start = 0
input.onLogoEvent(TouchButtonEvent.Pressed, function () {
start = input.runningTimeMicros()
})
input.onLogoEvent(TouchButtonEvent.Released, function () {
let duration = input.runningTimeMicros() - start
basic.showNumber(duration)
})
let start = input.runningTimeMicros()
// trigger ultrasonic & tunggu echo
let end = input.runningTimeMicros()
let duration = end - start
let t0 = input.runningTimeMicros()
basic.forever(function () {
if (input.runningTimeMicros() - t0 > 1000000) { // 1,000,000 µs = 1 s
led.toggle(2, 2)
t0 = input.runningTimeMicros()
}
})
Nilai akan menjadi sangat besar, jangan tunjuk di LED terlalu kerap.
Tidak sesuai untuk logik yang terlalu mudah (gunakan ms untuk timer biasa).
Sesuai untuk projek Robotik, Sains, Fizik dan IoT tepat
👉 “running time (micros)” baca masa dalam mikro-saat sejak program micro:bit mula berjalan. Ia 1000 kali lebih tepat daripada milisaat dan sangat penting untuk sensor ultrasonik, mengukur kelajuan, dan projek sains.
Blok ini ialah event block (blok peristiwa) di bawah kategori Input → Pins.
Fungsinya:
➡️ Menjalankan kod apabila pin P0 (atau pin lain yang dipilih) dilepaskan selepas ditekan/disentuh.
“Released” bermaksud keadaan apabila sambungan antara Pin P0 dan GND terputus.
Ini hanya berlaku selepas:
Pin P0 pernah disambung ke GND → dianggap “pressed”
Sambungan itu diputuskan semula → dianggap “released”
Contohnya:
lepaskan jari dari P0
lepaskan klip buaya dari GND
lepaskan push button
magnet / sensor tidak lagi menyentuh pin
pintu / suis tidak lagi bersentuhan
Event ini hanya dipanggil SEKALI, iaitu tepat pada saat sambungan terputus.
P0 = LOW → disambung dengan GND
(sensor input 0 = ditekan)
P0 kembali HIGH → tiada sambungan ke GND
Jadi blok ini akan trigger bila tekanan/ sentuhan sudah dilepaskan.
Blok on pin P0 released sangat berguna terutama untuk:
Tekan = ON
Lepas = OFF atau tindakan tertentu
Magnet lepas → pintu terbuka → event released berlaku.
Jika air kering (tiada sambungan) → released
Tekan = charge
Released = fire
Jika sambungan wayar diputuskan → trigger alarm
Tahan pin → robot bersedia
Released → robot mula bergerak
Event
Bila berlaku?
on pin P0 pressed
Bila P0 disambungkan ke GND
on pin P0 released
Bila sambungan P0-GND diputuskan
input.onPinReleased(TouchPin.P0, function () {
basic.showIcon(IconNames.Heart)
})
input.onPinReleased(TouchPin.P0, function () {
motors.forward(50)
})
input.onPinReleased(TouchPin.P0, function () {
music.playTone(523, 500)
})
let power = 0
input.onPinPressed(TouchPin.P0, function () {
power += 1 // charge power selama ditekan
})
input.onPinReleased(TouchPin.P0, function () {
basic.showNumber(power) // fire power
power = 0
})
Pin P0 sangat sensitif bila disentuh dengan jari (kerana konduksi).
Tekan = sambung ke GND
Lepas = putus sambungan
micro:bit baca ini sebagai pressed > released
👉 “on pin P0 released” bermaksud micro:bit akan jalankan arahan bila pin P0 dilepaskan daripada sambungan ke GND. Ia digunakan dalam projek butang, suis, sensor pintu, game, dan robot.
(atau 2g / 4g / 8g / 16g bergantung pilihan)
Blok set accelerometer range digunakan untuk:
Menentukan kepekaan (sensitivity) dan had bacaan maksimum sensor accelerometer micro:bit.
Accelerometer membaca pergerakan / tilt / gegaran dalam unit g-force (g).
Mengubah range akan menentukan:
✔️ sejauh mana sensor boleh mengukur daya pergerakan, dan
✔️ berapa sensitif bacaan accelerometer terhadap pergerakan kecil.
1g = daya graviti bumi (≈ 9.8 m/s²)
micro:bit sentiasa rasa 1g ke bawah kerana graviti.
G-force yang lebih tinggi = pergerakan / gegaran lebih kuat.
Biasanya micro:bit ada 4–5 pilihan:
Range
Maksimum boleh baca
Sensitiviti
1g
±1g
Sangat sensitif
2g
±2g
Sensitif
4g
±4g
Sederhana
8g
±8g
Rendah
16g (beberapa versi hanya)
±16g
Paling rendah
✔️ Bacaan lebih sensitif
✔️ Pergerakan kecil pun boleh dikesan
❌ Tetapi jika gerakan terlalu kuat, bacaan akan overflow atau clipped (tak tepat)
✔️ Boleh ukur gerakan lebih kuat, seperti goncangan laju atau hentakan
✔️ Sesuai untuk robot, permainan fizikal, motion tracking
❌ Tetapi bacaan untuk pergerakan kecil kurang sensitif
Gunakan apabila:
mengesan condongan kecil
projek keseimbangan (gyro-like)
permainan tilt (contoh: maze ball)
pengukur sudut meja / gasing perlahan
Gunakan untuk:
kawalan game sederhana
mengesan shake biasa
projek penjejak orientasi
Sesuai untuk:
robot bergerak laju
hentakan sederhana
simulasi gempa kecil
aktiviti fizikal murid
Untuk projek:
goncangan ekstrem
hentakan bola / kayu
sensor collision robot
eksperimen fizikal intensif
Untuk:
projek sains berimpak tinggi
melompat / hentakan kuat
pecutan sangat laju
Untuk mengelakkan:
Contoh: setting 1g tetapi murid goncang kuat → bacaan jadi tidak tepat.
Contoh: setting 8g tetapi nak baca tilt perlahan → nilainya terlalu kecil dan sukar diproses.
Jadi pemilihan range menentukan ketepatan projek.
input.setAccelerometerRange(AcceleratorRange.OneG)
input.setAccelerometerRange(AcceleratorRange.EightG)
input.setAccelerometerRange(AcceleratorRange.FourG)
👉 Blok set accelerometer range menetapkan tahap sensitif sensor accelerometer micro:bit. Range rendah (1g) sangat sensitif. Range tinggi (4g–8g) untuk pergerakan kuat. Pilihan range menentukan ketepatan bacaan pergerakan.
(atau nilai lain ikut tetapan)
Blok ini digunakan untuk:
Menetapkan nilai ambang (threshold) bagi bunyi “loud” supaya micro:bit tahu bila sesuatu bunyi dianggap kuat dan mencetuskan event.
Blok ini hanya berfungsi pada micro:bit V2 kerana ia mempunyai microphone terbina dalam.
Threshold bermaksud paras minimum suara / bunyi yang mesti dicapai untuk mengaktifkan event seperti:
Jika tahap bunyi melebihi threshold → loud
Jika di bawah threshold → quiet
Dengan kata lain:
👉 micro:bit hanya akan anggap bunyi “kuat” apabila nilai bacaan microphone melepasi threshold yang cikgu tetapkan.
Bacaan microphone micro:bit berada dalam julat 0 hingga 255
Maksud nilai:
0–50 → sangat senyap
50–120 → sederhana
120–255 → kuat / berpotensi loud
Dengan nilai 128:
✔️ micro:bit akan aktifkan event on loud sound apabila bunyi dalam bilik melebihi paras itu
✔️ bunyi biasa seperti bernafas, bunyi kipas, dan cakap perlahan tidak akan trigger event
✔️ hanya bunyi seperti tepukan kuat, jeritan halus atau hentakan meja akan mengaktifkan
Micro:bit mempunyai threshold default, tetapi:
Kelas bising → perlu threshold tinggi
Makmal sunyi → threshold rendah sudah cukup
Kadang-kadang bunyi kecil boleh mengaktifkan event → tak sesuai dalam projek tertentu.
Contoh:
“Tepuk sekali untuk ON, tepuk dua kali untuk OFF”
Sistem pengesan bunyi robot
Penggera suara
Main game tepuk tangan
Blok dropdown ada 2 pilihan:
Digunakan oleh event:
✔️ on loud sound
Digunakan oleh event:
✔️ on quiet sound
Nilai threshold menentukan bila micro:bit menukar status antara:
quiet → loud
loud → quiet
input.setSoundThreshold(SoundThreshold.Loud, 128)
input.onLoudSound(function () {
basic.showIcon(IconNames.Happy)
})
input.setSoundThreshold(SoundThreshold.Loud, 150)
input.onLoudSound(function () {
music.playTone(523, 500)
})
threshold = 80
threshold = 180
Bunyi kipas: ~30
Bercakap perlahan: ~60
Tepukan kecil: ~130
→ set threshold 100 atau 120
Borak murid: ~90–140
Tepukan kuat: > 160
→ threshold 140–180
Threshold rendah = lebih sensitif, mudah trigger
Threshold tinggi = kurang sensitif, perlu bunyi kuat
Gunakan LED / serial untuk lihat bacaan bunyi sebenar
👉 Blok ini menetapkan tahap bunyi yang dianggap “kuat”. Jika bacaan microphone melepasi nilai threshold (contoh 128), micro:bit akan mengaktifkan event on loud sound.
Kategori Music digunakan untuk
👉 menghasilkan bunyi & muzik dengan micro:bit, sama ada:
melalui speaker terbina dalam (micro:bit V2), atau
melalui buzzer / speaker luar yang disambung ke pin (biasanya P0 dan GND).
Semua blok di bawah kategori ini akan mengawal:
Nada (pitch) – bunyi tinggi / rendah
Tempo (kelajuan muzik) – laju atau perlahan
Beat / irama – panjang pendek bunyi
Melodi – main lagu automatik
Volume – kuat atau perlahan
Dalam kategori Music, murid akan jumpa beberapa jenis blok (nama mungkin sedikit berbeza ikut bahasa, tapi fungsi sama):
play tone … for … beat / mainkan nada … selama … beat
Main satu nada tertentu (contoh: Middle C, D, E…) untuk tempoh tertentu.
Sesuai untuk buat bunyi “beep”, bunyi amaran, bunyi klik, dsb.
start melody … repeating / once / mulakan melodi …
Main lagu yang telah disediakan (contoh: Dadadum, Birthday, Entertainer).
Boleh pilih sama ada ulang-ulang (forever) atau main sekali sahaja.
stop all sounds / henti semua bunyi
Hentikan semua muzik / nada yang sedang dimainkan.
Biasanya diguna bila butang lain ditekan atau game tamat.
set tempo to … bpm / tetapkan tempo
Ubah kelajuan muzik (beats per minute).
Nilai besar = lagu lebih laju, nilai kecil = lagu perlahan.
change tempo by …
Ubah tempo sedia ada (tambah atau kurangkan).
Sesuai kalau nak lagu jadi makin laju sedikit demi sedikit.
rest (beat) / rehat
Senyap untuk beberapa beat (tiada bunyi).
Digunakan untuk buat jarak / berhenti dalam irama.
(micro:bit V2) Sound effects / sound expression
Ada juga blok untuk bunyi seperti giggle, siren, hello, dsb.
Guna speaker on-board tanpa perlu buzzer luar.
Murid pilih blok dari kategori Music
Seret masuk ke dalam blok acara seperti:
on start
forever
on button A pressed
Bila syarat berlaku (contoh: butang A ditekan), micro:bit akan main bunyi atau lagu berdasarkan blok Music yang digunakan.
Contoh ringkas:
on button A pressed → play tone Middle C for 1 beat
➜ micro:bit berbunyi “ting!” bila butang A ditekan.
on start → start melody (Birthday) repeating forever
➜ micro:bit main lagu “birthday” berulang-ulang.
Boleh cikgu jelaskan kepada murid begini:
“Icon Music ini ialah tempat semua blok untuk buat bunyi dan lagu.
Dari sinilah kita boleh buat micro:bit berbunyi beep, main lagu, ubah kelajuan muzik dan hentikan bunyi.”
(Blok muzik dalam MakeCode Micro:bit)
Blok ini digunakan untuk:
Memainkan satu melodi (lagu pendek) mengikut tempo (bpm) yang ditetapkan, dan program akan berhenti seketika sehingga lagu selesai dimainkan.
Ia adalah blok untuk menghasilkan bunyi muzik menggunakan buzzer, speaker micro:bit V2, atau pin output (P0).
Mari kita pecahkan setiap bahagian dalam blok tersebut:
🎼 Kotak kelabu dengan ikon nota muzik berfungsi untuk memilih melodi:
Lagu-lagu preset (contoh: ba ding, jump up, enter, dll)
Melodi yang cikgu cipta sendiri menggunakan papan melodi (melody editor)
Contoh melodi yang boleh dipilih:
dadadum
entertainer
power up
funk
ringtone
melodi custom (manual)
BPM = Beats Per Minute (bilangan ketukan seminit)
Standard muzik = 120 bpm
Lebih laju (fast) = 160–200 bpm
Lebih perlahan (slow) = 60–90 bpm
Tempo menentukan:
kelajuan lagu dimainkan
panjang setiap nota
Ini bahagian penting!
until done = program akan pause (berhenti sementara) sehingga lagu habis dimainkan.
Maksudnya:
Semua kod selepas blok ini tidak akan berjalan sehingga micro:bit selesai main melodi.
Kod dalam forever loop juga akan berhenti seketika.
Jika tukar kepada:
in background → Lagu dimainkan sambil program lain berjalan
forever → lagu dimainkan berulang-ulang
once → sekali sahaja tanpa tahan program
Micro:bit akan:
✔️ mengeluarkan nada (pitch) setiap nota
✔️ mengikut panjang note (1/4, 1/8, 1/2 beat)
✔️ mengikut tempo yang ditetapkan
✔️ menghentikan seluruh program sehingga lagu siap (jika “until done”)
Ini sangat berguna untuk:
lagu kejayaan (success tune)
muzik latar
bunyi notifikasi
alarm kebakaran simulasi
amaran air naik
alarm pintu dibuka
bila murid menang
bila robot sampai checkpoint
bila objek dikesan sensor
setiap kali tekan logo
setiap kali shake micro:bit
sebelum robot mula bergerak
intro sebelum animasi LED berjalan
music.playMelody("C5 B A G F E D C ", 120)
input.onButtonPressed(Button.A, function () {
music.playMelody("C5 B A G A B C5 C5", 160)
})
music.playMelody("E B C5 A B G A F", 120)
basic.showIcon(IconNames.Heart)
Icon hanya muncul selepas lagu selesai.
Jika micro:bit V2 → bunyi terus keluar dari speaker terbina dalam.
Jika micro:bit V1 → perlu sambung buzzer pada P0 dan GND.
“Until done” boleh membuat robot berhenti sementara melodi dimainkan — kena hati-hati!
👉 Blok ini memainkan satu melodi yang dipilih pada tempo tertentu. Jika “until done”, micro:bit akan tunggu sampai lagu habis dimainkan sebelum sambung program.
(Blok bunyi dalam MakeCode micro:bit)
Blok ini digunakan untuk:
Memainkan satu nada (tone) tertentu untuk tempoh masa tertentu, mengikut unit “beat”, dan program akan berhenti seketika sehingga nada itu selesai dimainkan.
Ia adalah fungsi bunyi asas untuk menghasilkan nota tunggal.
Mari kita pecahkan satu per satu.
Ini ialah nota muzik yang hendak dimainkan.
Micro:bit boleh menghasilkan banyak nota:
Middle C
D
E
F
G
A
B
C5
dan banyak lagi.
“Middle C” ialah nota asas (C) yang berada di tengah-tengah skala piano.
Setiap nota ini sebenarnya ialah frequency (Hz) — contohnya:
Nota
Frekuensi
C (Middle C)
262 Hz
D
294 Hz
E
330 Hz
F
349 Hz
G
392 Hz
A
440 Hz
B
494 Hz
micro:bit menghasilkan bunyi dengan menghantar gelombang frekuensi ini ke speaker atau buzzer.
Bahagian ini menentukan tempoh tone dimainkan.
Beat = kiraan masa berdasarkan tempo muzik.
Default tempo micro:bit = 120 BPM
Dalam 120 BPM:
1 beat = 0.5 saat
2 beat = 1 saat
0.5 beat = 0.25 saat
Jika cikgu tukar tempo, durasi beat akan berubah.
Jika tempo = 60 BPM (perlahan):
1 beat = 1 saat
Jika tempo = 180 BPM (laju):
1 beat = 0.33 saat
Ini bahagian penting.
until done = program “pause” sehingga nada selesai dimainkan.
Maknanya:
✔️ Kod seterusnya tidak berjalan selagi nada tak habis
✔️ Dalam loop forever, micro:bit akan berhenti sementara
✔️ Sesuai untuk bunyi yang perlu “selesai dulu”, seperti:
intro
bunyi notifikasi
bunyi kemenangan
Boleh ditukar ke:
in background → nada dimainkan sambil program lain berjalan
once → main nada sekali sahaja (tanpa tunggu)
micro:bit menghasilkan nada dengan:
menghantar frekuensi gelombang square wave
pada pin audio (buzzer atau speaker)
untuk tempoh masa yang ditetapkan
micro:bit V2: ada speaker built-in
micro:bit V1: perlu buzzer di P0 + GND
Blok ini sangat berguna untuk:
bunyi mula bergerak
bunyi berhenti
bunyi collision
amaran air naik
amaran pintu dibuka
amaran bunyi kuat
main lagu not demi not
buat melodi sendiri
“piano micro:bit”
bunyi score
bunyi kalah
bunyi power-up
music.playTone(262, music.beat(BeatFraction.Whole))
music.playTone(262, music.beat(BeatFraction.Whole))
music.playTone(330, music.beat(BeatFraction.Whole))
music.playTone(392, music.beat(BeatFraction.Whole))
music.playTone(262, music.beat(BeatFraction.Half), music.PlaybackMode.InBackground)
“Until done” menghentikan robot / animasi buat sementara
Gunakan “in background” untuk robot supaya tone tak ganggu pergerakan
Jika micro:bit V1 → pastikan sambung buzzer di P0
👉 “play tone Middle C for 1 beat until done” bermaksud micro:bit memainkan satu nota C selama 1 beat, dan program berhenti sekejap sampai bunyi habis.
(Blok bunyi dalam MakeCode micro:bit)
Blok ring tone (Hz) digunakan untuk:
Menghasilkan satu nada berfrekuensi tertentu secara berterusan (continuous tone) tanpa berhenti sehingga diarahkan berhenti.
Ini bermaksud:
✔️ Nada akan terus berbunyi
✔️ Tidak ada had masa
✔️ Program tidak berhenti semasa nada dimainkan
✔️ Nada hanya berhenti apabila kita hentikan secara manual menggunakan rest atau stop all sounds
Hz = Hertz, unit frekuensi — jumlah getaran sesaat.
Dalam muzik:
Nada rendah = frekuensi rendah (contoh: 100 Hz)
Nada tinggi = frekuensi tinggi (contoh: 1000 Hz)
Contoh frekuensi nota:
Nota
Frekuensi
Middle C
262 Hz
D
294 Hz
E
330 Hz
G
392 Hz
A
440 Hz
“Middle C” adalah shortcut untuk frekuensi 262 Hz.
Blok ini sebenarnya boleh pilih:
nota (C, D, E, F, G, A, B)
nombor frekuensi (contoh: 1000 Hz)
Blok
Fungsi
play tone… for (duration)
Nada dimainkan untuk tempoh tertentu
ring tone (Hz)
Nada dimainkan tanpa henti, sehingga dihentikan
Blok ini sama seperti “bunyi berterusan” (continuous beep).
micro:bit menghantar gelombang square wave pada frekuensi tetap (contoh: 262 Hz) terus-menerus ke speaker/buzzer.
Nada tidak akan berhenti sehingga kita:
bentuk nada baru, atau
panggil music.rest(…), atau
panggil music.stopAllSounds()
Blok ini sangat berguna untuk projek:
alarm pintu
alarm keselamatan
penggera banjir
robot mengundur / emergency
robot reverse dengan bunyi “beeeep”
Nada boleh berubah ikut sensor:
semakin dekat → frekuensi semakin tinggi
semakin jauh → frekuensi semakin rendah
Dengan pembacaan magnet → bunyi berubah
Untuk dengar frekuensi 200–2000 Hz
(suara manusia berada sekitar 300–3400 Hz)
music.ringTone(262)
music.rest(music.beat(BeatFraction.Whole))
ATAU:
music.stopAllSounds()
let jarak = 0
basic.forever(function () {
jarak = sensorUltrasonik()
music.ringTone(jarak * 50)
})
input.onPinReleased(TouchPin.P0, function () {
music.ringTone(440)
})
input.onPinPressed(TouchPin.P0, function () {
music.stopAllSounds()
})
Nada berterusan boleh bising — hentikan menggunakan stopAllSounds()
Untuk micro:bit V1 → perlu buzzer pada P0
Untuk micro:bit V2 → speaker built-in boleh memainkan bunyi terus
Elakkan frekuensi terlalu tinggi (lebih 2000 Hz) — boleh menyakitkan telinga
👉 “ring tone (Hz)” memainkan nada berterusan pada frekuensi tertentu. Nada tidak berhenti sehingga diberi arahan untuk berhenti. Sesuai untuk alarm dan bunyi amaran.
(Blok muzik dalam MakeCode Micro:bit)
Blok rest for 1 beat digunakan untuk:
Menghentikan penghasilan bunyi (senyap) untuk tempoh tertentu berdasarkan bilangan “beat”.
Dengan kata lain:
✔️ micro:bit tidak memainkan sebarang bunyi
✔️ ia tunggu (pause) untuk tempoh beat yang ditetapkan
✔️ digunakan untuk menghasilkan “rehat” dalam muzik, sama seperti nota senyap dalam muzik sebenar
= berhenti menghasilkan bunyi
= “silent note”
Beat ialah unit masa dalam muzik, bergantung pada tempo (BPM).
Default micro:bit = 120 BPM
→ 1 beat = 0.5 saat
Jika cikgu ubah tempo, durasi beat berubah.
Tempo (BPM)
Tempoh 1 beat
60 (perlahan)
1 saat
120 (standard)
0.5 saat
180 (laju)
0.33 saat
Blok ini digunakan dalam muzik untuk:
Supaya lagu tidak berbunyi bersambung tanpa henti.
Contoh:
jika sebelum ini guna ring tone (Hz),
blok rest akan mematikan bunyi itu sementara.
Contoh:
nota, rest, nota
beep-beep (sekejap senyap), beep
Ia pause dalam sistem muzik, tetapi tak hold program seperti play tone until done.
Blok
Fungsi
rest for 1 beat
Hentikan bunyi buat sementara waktu (durasi tertentu)
stop all sounds
Hentikan SEMUA bunyi serta-merta tanpa tempoh
music.playTone(262, music.beat(BeatFraction.Whole))
music.rest(music.beat(BeatFraction.Half))
music.playTone(330, music.beat(BeatFraction.Whole))
music.ringTone(440)
music.rest(music.beat(BeatFraction.Whole)) // bunyi akan berhenti
music.playTone(392, music.beat(BeatFraction.Quarter))
music.rest(music.beat(BeatFraction.Quarter))
basic.forever(function () {
music.playTone(262, music.beat(BeatFraction.Eighth))
music.rest(music.beat(BeatFraction.Eighth))
})
micro:bit akan:
menghentikan output bunyi
menunggu selama tempoh beat
kemudian sambung program selepas itu
Rest tidak menghalang program lain seperti LED, input dan sensor.
“Rest” bukan stop selamanya, ia hanya “senyap” sekejap.
Durasi beat bergantung pada tempo.
Bunyi sebelumnya (tone / ring tone) akan dipotong.
👉 “rest for 1 beat” ialah arahan untuk micro:bit berhenti mengeluarkan bunyi selama 1 beat. Ia digunakan sebagai jeda atau rehat dalam muzik, sama seperti nota senyap dalam lagu.
(Blok bunyi dalam MakeCode micro:bit)
Blok set volume digunakan untuk:
Menentukan tahap kekuatan bunyi (volume) untuk semua bunyi yang dimainkan oleh micro:bit, sama ada:
melodi
tone
ring tone
sound effects
muzik latar
Ia mengawal kekuatan audio daripada 0 hingga 255.
micro:bit menggunakan skala:
0 = senyap (mute)
1–50 = sangat perlahan
50–120 = sederhana
120–200 = kuat
200–255 = paling kuat / maksimum
Nilai dalam gambar (127) ialah tahap pertengahan antara kuat dan sederhana.
Blok ini menetapkan volume global, bermaksud ia mengawal:
✔️ semua nota
✔️ semua melodi
✔️ semua kesan bunyi
✔️ semua bunyi yang dimainkan selepas arahan ini
Jika ada bunyi sedang dimainkan, perubahan volume akan terus mempengaruhi bunyi itu.
Blok volume digunakan apabila cikgu mahu:
kelas senyap → volume rendah
luar sekolah → volume tinggi
bunyi amaran layar → kuat
bunyi menu / klik → perlahan
intro lembut → volume kecil
chorus → volume kuat
Murid Tahun 6 suka pasang volume maksimum 😅
Jadi cikgu boleh lock volume pada nilai tertentu.
Contoh:
semakin dekat objek → volume semakin kuat
semakin jauh → volume perlahan
micro:bit tidak mempunyai butang volume.
Jadi volume hanya boleh dikawal melalui coding.
Blok ini mempengaruhi:
Blok
Dipengaruhi Volume?
play tone
✔️ Ya
ring tone (Hz)
✔️ Ya
play melody
✔️ Ya
rest
❌ Rest tetap senyap
sound effects
✔️ Ya
stop all sounds
Tidak ubah volume, hanya hentikan bunyi
music.setVolume(127)
music.playTone(262, music.beat(BeatFraction.Whole))
music.setVolume(input.lightLevel())
music.playTone(440, music.beat(BeatFraction.Half))
music.setVolume(40)
music.playMelody("E D C D E E E -", 120)
music.setVolume(200)
music.startMelody(music.builtInMelody(Melodies.PowerUp), MelodyOptions.Once)
micro:bit V1 → perlu buzzer di P0 untuk bunyi
micro:bit V2 → ada speaker built-in, volume lebih kuat
volume 255 terlalu kuat jika murid guna dekat telinga
jika bunyi masih perlahan, pastikan:
tiada “rest”
tiada konflik audio
V1 buzzer tersambung dengan betul
👉 “set volume 127” menetapkan kekuatan bunyi micro:bit pada tahap 127 daripada 255. Semua bunyi selepas itu akan mengikut volume ini.
(Reporter Block – blok pembaca nilai dalam MakeCode micro:bit)
Blok volume digunakan untuk:
Membaca dan mendapatkan nilai semasa tahap bunyi (volume) micro:bit dalam bentuk nombor, dalam julat 0 hingga 255.
Ia tidak mengubah volume.
Ia hanya membaca volume yang sedang digunakan.
Ini ialah reporter block (blok output nilai), yang biasanya digunakan dalam:
kiraan
syarat if
paparan LED
perubahan dinamik
Nilai yang blok ini berikan ialah:
0 → senyap (mute)
1–50 → sangat perlahan
50–120 → sederhana
120–180 → kuat
180–255 → maksimum
Sebagai contoh:
Jika cikgu sebelum ini set:
music.setVolume(150)
Maka:
music.volume()
akan pulangkan nilai 150.
Untuk tujuan pengajaran:
“berapa kuat bunyi sekarang?”
“bagaimana perubahan volume berlaku?”
Contoh:
jika volume > 200 → beri amaran
jika volume < 50 → naikkan sedikit
Cikgu boleh ubah volume mengikut:
cahaya
bunyi
jarak
masa
Untuk buat fungsi “mute” dan “unmute”.
basic.showNumber(music.volume())
if (music.volume() < 50) {
music.setVolume(100)
}
Semakin cerah → semakin kuat bunyi.
music.setVolume(input.lightLevel())
(Tetapi jika nak paparkan volume semasa:)
basic.showNumber(music.volume())
let asal = music.volume()
input.onButtonPressed(Button.A, function () {
asal = music.volume()
music.setVolume(0)
})
input.onButtonPressed(Button.B, function () {
music.setVolume(asal)
})
let jarak = readUltrasonic()
music.setVolume(Math.map(jarak, 0, 30, 255, 50))
music.ringTone(440)
Blok volume bukan untuk tukar volume.
Ia hanya mengambil nilai volume semasa.
Untuk ubah volume → guna blok:
set volume …
change volume by …
👉 Blok volume membaca dan memberi nilai kekuatan bunyi micro:bit (0–255). Ia tidak mengubah volume, tetapi memberitahu volume semasa yang sedang digunakan.
(Blok muzik dalam MakeCode micro:bit)
Blok stop all sounds digunakan untuk:
Menghentikan serta-merta SEMUA bunyi yang sedang dimainkan oleh micro:bit, tanpa mengira jenis bunyi atau bagaimana ia dimulakan.
Ini termasuk:
✔️ play tone
✔️ play melody
✔️ ring tone
✔️ start melody
✔️ sound effects
✔️ nada berterusan
✔️ muzik latar
Semua audio akan dihentikan serta-merta apabila blok ini dijalankan.
Apabila micro:bit menemui blok ini:
Ia mematikan speaker
Menghentikan gelombang bunyi square-wave
Memberhentikan setiap bunyi aktif, termasuk yang dimainkan di background
Bunyi seterusnya hanya keluar apabila blok bunyi lain digunakan
Ini adalah “emergency stop” untuk audio.
Blok
Kesan
rest for 1 beat
Hentikan bunyi sementara, mengikut masa
stop all sounds
Hentikan semua bunyi serta-merta
set volume 0
Bunyi masih “main” tetapi tidak kedengaran
ring tone
Bunyi berterusan sehingga dihentikan
play tone for …
Main nada untuk tempoh masa
stop all sounds adalah cara paling cepat dan drastik untuk menghentikan bunyi.
Blok ini sangat berguna dalam projek yang melibatkan:
Bila pin ditutup → alarm ON
Bila pin dibuka → alarm OFF dengan serta-merta (stop all sounds)
Robot reverse → bunyi beep
Bila berhenti → hentikan bunyi terus
Bila pemain kalah → berhenti semua bunyi
Bunyi power-up tamat → hentikan untuk reset semula
Jika guna ring tone dan lupa hentikan, bunyi tidak akan berhenti
stop all sounds boleh hentikan serta-merta
Kadang-kadang murid buat bunyi kuat sangat…
→ Tekan butang A untuk “mute cepat”.
input.onButtonPressed(Button.B, function () {
music.stopAllSounds()
})
input.onPinReleased(TouchPin.P0, function () {
music.ringTone(880)
})
input.onPinPressed(TouchPin.P0, function () {
music.stopAllSounds()
})
motors.forward(50)
music.ringTone(440)
// bila berhenti
music.stopAllSounds()
motors.stop()
music.startMelody(music.builtInMelody(Melodies.Ringtone), MelodyOptions.InBackground)
basic.pause(1000)
music.stopAllSounds()
Untuk micro:bit V1, pastikan buzzer pada P0
Untuk micro:bit V2, speaker built-in akan berhenti serta-merta
Jika nada kembali berbunyi selepas stop, ada blok bunyi lain dalam forever loop
👉 “stop all sounds” menghentikan SEMUA bunyi micro:bit serta-merta. Sangat berguna untuk hentikan alarm, hentikan bunyi game, dan menghentikan nada berterusan.
Blok change tempo by (bpm) digunakan untuk:
Menukar tempo muzik micro:bit dengan menambah atau mengurangkan nilai BPM yang sedang digunakan.
Ia adalah perubahan secara relatif, bukan nilai tetap.
BPM = Beats Per Minute
➜ jumlah ketukan per minit dalam muzik
BPM menentukan kelajuan lagu:
BPM tinggi → lagu laju
BPM rendah → lagu perlahan
Contoh:
60 BPM = slow
120 BPM = standard
180 BPM = fast / upbeat
Blok
Fungsi
set tempo to …
Tetapkan tempo kepada nilai tertentu
change tempo by …
Tambah atau tolak dari tempo sedia ada
Contoh:
Jika tempo sekarang 120 BPM:
change tempo by 20 → tempo menjadi 140 BPM
change tempo by -20 → tempo menjadi 100 BPM
SEMUA blok yang menggunakan konsep beat, termasuk:
✔️ play melody
✔️ play tone for 1 beat
✔️ rest for 1 beat
✔️ start melody
Bila tempo meningkat:
1 beat = lebih cepat
Melodi dimainkan lebih laju
Jeda lebih pendek
BPM
Durasi 1 beat
60
1.00 s
90
0.66 s
120
0.50 s
140
0.42 s
180
0.33 s
Blok ini sangat sesuai untuk:
Semakin lama bermain → tempo semakin laju
Makin sukar → tempo bertambah 10 BPM setiap kali victory
Suasana tegang → tempo meningkat
Suasana tenang → tempo perlahan
Chorus cepat → tempo meningkat
Verse perlahan → tempo berkurang
Cth: ikut suhu / cahaya / arah / bunyi.
input.onButtonPressed(Button.A, function () {
music.changeTempoBy(20)
})
input.onButtonPressed(Button.B, function () {
music.changeTempoBy(-20)
})
music.changeTempoBy(5)
Semakin kuat suara → semakin laju muzik.
music.changeTempoBy(input.soundLevel() / 10)
Tempo tidak boleh negatif
Tempo terlalu tinggi akan membuat melodi “terlalu cepat”
Jika terlalu perlahan, melodi mungkin kedengaran seperti robot 😄
Sesuai dengan micro:bit V1 dan V2
👉 “change tempo by (bpm) 20” bermaksud: tambahkan kelajuan lagu sebanyak 20 BPM daripada tempo semasa. Tempo yang lebih tinggi menjadikan lagu dimainkan lebih cepat.
(Blok Muzik – MakeCode micro:bit)
Blok set tempo to (bpm) digunakan untuk:
Menetapkan kelajuan muzik (tempo) bagi semua bunyi yang menggunakan unit beat.
BPM = Beats Per Minute
Ia menentukan berapa cepat atau perlahan sesuatu bunyi atau melodi dimainkan.
SEMUA blok muzik yang menggunakan beat, termasuk:
✔️ play melody
✔️ play tone for 1 beat
✔️ rest for 1 beat
✔️ start melody
✔️ kesan bunyi yang menggunakan beat
Dengan kata lain:
Jika tempo tinggi → semua bunyi menjadi lebih laju
Jika tempo rendah → bunyi menjadi lebih perlahan
BPM = bilangan ketukan dalam 1 minit.
Contoh:
60 BPM → 60 ketukan seminit (perlahan)
120 BPM → 120 ketukan seminit (standard)
180 BPM → 180 ketukan seminit (laju)
Berikut adalah tempoh 1 beat mengikut BPM:
BPM
Durasi 1 beat
60
1.00 saat
90
0.66 saat
120
0.50 saat
150
0.40 saat
180
0.33 saat
Jadi blok set tempo to 120 bermaksud:
🡆 setiap 1 beat = 0.5 saat
Blok
Fungsi
set tempo to …
Tetapkan tempo secara mutlak (nilai tetap)
change tempo by …
Tambah/tolak tempo sedia ada
Contoh:
Jika tempo asal = 80 BPM
set tempo to 120 → terus jadi 120
change tempo by 20 → jadi 100
Tempo mempengaruhi:
Nota 1 beat → dimainkan perlahan/cepat bergantung pada BPM.
rest for 1 beat ikut durasi beat semasa.
Lagu bawaan micro:bit (contoh: Dadadum, Birthday Tune) akan berubah kelajuannya mengikut tempo yang ditetapkan.
music.setTempo(120)
music.playMelody("C D E F G A B C5", 120)
music.setTempo(60)
music.playTone(262, music.beat(BeatFraction.Whole))
music.setTempo(180)
music.playMelody("G A G E D C D E", 180)
Bilik cerah → muzik laju
Bilik gelap → muzik perlahan
music.setTempo(input.lightLevel())
Supaya melodi sedap dan tidak terlalu laju.
music.setTempo(100)
music.startMelody(music.builtInMelody(Melodies.Entertainer), MelodyOptions.Once)
BPM tidak boleh negatif
BPM terlalu tinggi (lebih 250) akan membuat melodi laju sangat
BPM terlalu rendah (kurang 40) akan menjadikan lagu terlalu perlahan
micro:bit V1 & V2 kedua-duanya menyokong blok tempo
👉 “set tempo to 120 bpm” bermaksud micro:bit akan memainkan semua bunyi muzik pada kelajuan 120 ketukan seminit. Tempo tinggi = lagu laju. Tempo rendah = lagu perlahan.
Blok ini adalah unit masa yang digunakan oleh micro:bit untuk mengukur durasi bunyi dalam semua blok muzik.
Blok ini menentukan tempoh masa untuk:
✔️ memainkan nada (tone)
✔️ memainkan melodi (melody)
✔️ rehat / jeda bunyi (rest)
✔️ tempoh setiap langkah dalam lagu
Secara ringkas, 1 beat = satu ketukan masa muzik, dan durasinya bergantung kepada tempo (BPM) yang sedang digunakan oleh micro:bit.
Durasi 1 beat berubah-ubah ikut nilai BPM yang ditetapkan melalui blok:
set tempo to (bpm) …
Gunakan formula:
1 beat duration = 60 / BPM dalam saat
Contoh:
BPM
Durasi 1 beat
60 bpm
1.00 saat
90 bpm
0.67 saat
120 bpm
0.50 saat
180 bpm
0.33 saat
Jadi, jika tempo = 120 BPM, blok 1 beat bermaksud:
➡️ 0.5 saat
Blok 1 beat digunakan sebagai unit masa dalam blok lain seperti:
play tone Middle C for 1 beat
rest for 1 beat
Setiap not dalam melodi menggunakan unit beat.
✔ Lebih mudah untuk mencipta muzik
✔ Sesuai dengan standard muzik sebenar
✔ Lagu lebih konsisten walaupun tempo berubah
✔ Boleh digunakan dalam komposisi melodi kompleks
music.playTone(262, music.beat(BeatFraction.Whole))
Parameter BeatFraction.Whole = 1 beat.
play tone Middle C for 0.25 beat
Jika tempo = 120 BPM → 0.25 beat = 0.125 saat
play tone 440Hz for 1 beat
rest for 0.5 beat
play tone 440Hz for 1 beat
Jika tempo = 60 → 1 beat = 1 saat
Jika tempo = 180 → 1 beat = 0.33 saat
Tetapi blok muzik kekal sama:
play tone Middle C for 1 beat
Mudah untuk ajar murid muzik tanpa kira masa secara manual.
👉 “1 beat” ialah unit masa muzik. Panjangnya bergantung pada tempo (BPM). Tempo laju = beat pendek. Tempo perlahan = beat panjang.
Blok tempo (bpm) digunakan untuk mendapatkan nilai tempo muzik semasa yang sedang digunakan oleh micro:bit.
Nilai tempo ini diukur dalam unit:
(Bilangan beat dalam masa 1 minit)
Blok ini tidak mengubah tempo, tetapi membaca tempo yang sedang digunakan.
Blok ini akan memberikan nombor BPM (integer).
Contoh:
Jika tempo ditetapkan kepada 120 BPM, blok ini akan memulangkan nilai 120.
Jika tempo ditetapkan kepada 200 BPM, ia akan pulangkan 200.
Blok ini digunakan apabila kita mahu:
✔️ Membina muzik yang adaptif
✔️ Mengubah corak bunyi berdasarkan tempo
✔️ Memaparkan tempo pada LED
✔️ Menggunakan tempo dalam pengiraan matematik
✔️ Membuat sistem muzik interaktif / penjana lagu automatik
Tempo menentukan berapa lama 1 beat berlangsung.
Formula:
Contoh:
Tempo (BPM)
Durasi 1 beat
60 BPM
1.00 saat
120 BPM
0.50 saat
180 BPM
0.33 saat
240 BPM
0.25 saat
Maka blok ini sangat berguna untuk kiraan masa muzik.
basic.showNumber(music.tempo())
if (music.tempo() > 200) {
music.setTempo(120)
}
Semakin laju tempo → nada semakin tinggi.
let pitch = music.tempo() * 2
music.playTone(pitch, music.beat(BeatFraction.Whole))
Robot buat bunyi laju bila bergerak cepat.
music.playTone(music.tempo(), 50)
👉 Blok tempo (bpm) memberikan nilai tempo muzik semasa. Tempo menentukan kelajuan muzik dan panjang setiap beat. Ia digunakan untuk membaca tempo, bukan menetapkannya.
Blok ini digunakan untuk memainkan melodi yang telah ditetapkan (preset melody) pada micro:bit tanpa menghentikan program lain.
Ini bermaksud melodi dimainkan serentak dengan kod lain — running asynchronously.
Blok ini akan:
Melodi ini adalah salah satu melodi standard micro:bit seperti:
dadadum
entertainer
prelude
ode
nyan
ringtone
birthday
wedding
funfair
punchline
chase
power up
power down
Ini bermaksud:
Kod lain tetap berjalan
micro:bit tidak menunggu melodi habis
Fungsi lain seperti LED, sensor, input masih beroperasi serentak
Biasanya, jika kita gunakan:
play melody … until done
➡️ micro:bit akan berhenti semua proses lain sehingga melodi tamat.
Tetapi bila gunakan:
play melody … in background
➡️ melodi berjalan seiring dengan kod lain tanpa ganggu proses.
Robot berjalan sambil main lagu:
music.playMelody("dadadum", 120, MelodyOptions.InBackground)
basic.forever(function() {
basic.showIcon(IconNames.Heart)
})
Melodi main, ikon terus berubah.
music.playMelody("dadadum", 120, MelodyOptions.InBackground)
motors.forward(100)
Bot terus bergerak tanpa tunggu melodi selesai.
Sensor membaca nilai walaupun muzik sedang bermain:
music.playMelody("dadadum", 120, MelodyOptions.InBackground)
if (input.temperature() > 30) {
basic.showString("HOT!")
}
Blok ini mengikuti tempo yang ditetapkan melalui:
set tempo to (bpm)
Jika tempo cepat → melodi “dadadum” dimainkan lebih laju
Jika tempo perlahan → melodi dimainkan lebih perlahan
👉 Blok ini memainkan melodi ‘dadadum’ sambil membenarkan program lain berjalan pada masa yang sama. Ia tidak menghentikan micro:bit daripada menjalankan kod lain.
Blok ini digunakan untuk memberhentikan melodi yang sedang dimainkan oleh micro:bit, sama ada dimainkan:
✔️ secara biasa (until done)
✔️ secara serentak / asynchronous (in background)
Blok ini menghentikan SEMUA melodi aktif serta-merta.
Seperti:
dadadum
entertainer
prelude
chase
birthday
wedding
ringtone
power up / power down
dan lain-lain.
Jika melodi dimainkan menggunakan:
play melody … in background
Melodi tidak berhenti sendiri —
maka blok ini digunakan untuk menghentikannya.
Jika melodi diulang (repeat), blok ini menghentikannya segera.
Blok ini TIDAK menghentikan:
✖ nada ring tone (ring tone Hz)
✖ nada satu bunyi (play tone …)
✖ bunyi daripada blok Sound Effects (jika extension digunakan)
Untuk hentikan semua bunyi → guna stop all sounds.
Biasanya ada beberapa pilihan:
Pilihan
Fungsi
all
hentikan semua melodi yang sedang dimainkan
background
hentikan melodi yang dimainkan in background sahaja
foreground
hentikan melodi yang dimainkan secara normal
—
Dalam versi micro:bit V2, paling biasa digunakan ialah:
stop melody all
Contoh: tekan butang → matikan melodi.
input.onButtonPressed(Button.A, function () {
music.stopMelody(MelodyStopOptions.All)
})
Permainan bermula dengan lagu → bila game over, hentikan melodi.
Robot bergerak sambil melodi dimainkan in background → berhenti apabila sensor dikesan.
music.playMelody("dadadum", 120, MelodyOptions.InBackground)
basic.pause(5000)
music.stopMelody(MelodyStopOptions.All)
Jika tidak hentikan melodi lama, dua lagu boleh bertindih.
input.onLogoEvent(TouchButtonEvent.Pressed, function () {
music.stopMelody(MelodyStopOptions.All)
})
music.playMelody("entertainer", 120, MelodyOptions.InBackground)
basic.pause(3000)
music.stopMelody(MelodyStopOptions.All)
if (input.temperature() > 30) {
music.stopMelody(MelodyStopOptions.All)
}
👉 “stop melody all” menghentikan SEMUA melodi preset yang sedang dimainkan, termasuk yang berjalan di latar belakang.
Blok ini adalah event handler (blok peristiwa) dalam MakeCode yang akan dijalankan setiap kali satu not muzik dimainkan oleh micro:bit.
Maknanya:
👉 Setiap kali ada nota dalam melodi yang berbunyi, kod di dalam blok ini akan diaktifkan secara automatik.
Contoh: dalam melodi
C D E F G
Untuk setiap huruf (nota), blok ini akan mengaktifkan event.
Contohnya:
✔️ Animasi LED berkelip mengikut setiap nota
✔️ Robot bergerak sedikit setiap kali bunyi keluar
✔️ Kira jumlah nota dalam lagu
✔️ Buat cahaya RGB ikut frekuensi nota
✔️ Papar nama nota setiap kali dimainkan
Contoh:
dadadum
entertainer
ringtone
funfair
melodi buatan sendiri dari editor muzik
Event ini aktif apabila:
✔️ play melody … digunakan
✔️ play melody … in background digunakan
✔️ melodi dimainkan semasa permainan
✔️ tempo berubah tetapi melodi tetap berjalan
✔️ setiap not, bukan keseluruhan lagu
Segala kod dalam ruangnya akan dijalankan sekali setiap kali SATU NOT dimainkan.
Contohnya:
music.onEvent(MusicEvent.MelodyNotePlayed, function () {
basic.showIcon(IconNames.Heart)
})
Jika melodi ada 20 nota → event berlaku 20 kali.
music.onEvent(MusicEvent.MelodyNotePlayed, function () {
basic.showLed(2, 2, true)
basic.pause(50)
basic.clearScreen()
})
Setiap nota → LED berkelip.
let kiraNota = 0
music.onEvent(MusicEvent.MelodyNotePlayed, function () {
kiraNota += 1
})
Selepas lagu habis, murid boleh lihat berapa nota telah dimainkan.
music.onEvent(MusicEvent.MelodyNotePlayed, function () {
pins.servoWritePin(AnalogPin.P0, 0)
basic.pause(100)
pins.servoWritePin(AnalogPin.P0, 180)
})
Setiap not → servo bergerak kiri-kanan.
music.onEvent(MusicEvent.MelodyNotePlayed, function () {
basic.showNumber(music.tempo())
})
music.onEvent(MusicEvent.MelodyNotePlayed, function () {
strip.showRainbow(1, 360)
})
Dropdown biasanya mengandungi:
Event
Fungsi
melody note played
setiap kali satu nota dimainkan
melody started
apabila lagu bermula
melody ended
apabila lagu habis dimainkan
Ini memberi kawalan penuh untuk membuat projek interaktif muzik.
👉 “music on melody note played” ialah blok peristiwa yang aktif setiap kali satu nota muzik dimainkan. Ia membolehkan kita membuat animasi, kiraan, pergerakan dan kesan khas mengikut rentak melodi.
Blok ini digunakan untuk memainkan bunyi efek (sound effect) jenis giggle pada micro:bit V2 (kerana hanya V2 ada mikrofon dan speaker terbina).
Sound effect kategori ini termasuk bunyi seperti:
giggle
happy
sad
slide
twinkle
soar
jump
magic
dan banyak lagi.
Giggle ialah bunyi efek ketawa kecil / bunyi comel yang telah diprogramkan dalam micro:bit V2.
Ia digunakan untuk projek animasi, watak robot, permainan interaktif, atau reaksi “gembira”.
Ini sangat penting.
Bila gunakan until done, micro:bit:
➡️ akan memainkan bunyi giggle sampai habis,
➡️ dan TIDAK akan menjalankan kod lain sehingga bunyi selesai.
Program “pause” sementara bunyi dimainkan.
Pilihan
Apa berlaku?
until done
Micro:bit berhenti sementara hingga bunyi habis
in background
Bunyi dimainkan sambil kod lain berjalan serentak
Blok cikgu gunakan ialah until done → program pause.
Jika cikgu guna blok:
play sound giggle until done
Micro:bit akan:
Memainkan bunyi ketawa comel
Tunggu bunyi habis
Barulah teruskan dengan arahan seterusnya
input.onLogoEvent(TouchButtonEvent.Pressed, function () {
music.playSoundEffect(music.sounds(Sounds.Giggle), SoundExpressionPlayMode.UntilDone)
})
if (score == 10) {
music.playSoundEffect(music.sounds(Sounds.Giggle), SoundExpressionPlayMode.UntilDone)
basic.showString("YOU WIN!")
}
basic.showIcon(IconNames.Happy)
music.playSoundEffect(music.sounds(Sounds.Giggle), SoundExpressionPlayMode.UntilDone)
if (input.soundLevel() > 180) {
music.playSoundEffect(music.sounds(Sounds.Giggle), SoundExpressionPlayMode.UntilDone)
}
👉 “play giggle until done” memainkan bunyi ketawa sampai habis, dan micro:bit berhenti seketika sehingga bunyi selesai dimainkan.
Blok ini digunakan untuk memainkan sound effect yang direka sendiri menggunakan Sound Editor (editor bunyi) dalam MakeCode.
Editor bunyi ini hanya tersedia untuk micro:bit V2 (kerana V2 ada speaker terbina).
Blok ini:
Anda boleh mencipta bunyi dengan pelbagai parameter seperti:
pitch (frekuensi)
volume
waveform
envelope
vibrato
duration
bentuk gelombang bunyi
Semua bunyi yang anda hasilkan akan muncul dalam blok ini sebagai ikon nota + gelombang bunyi.
Micro:bit akan berhenti sementara dan menunggu bunyi habis dimainkan.
➡ Program berhenti seketika
➡ Tiada arahan lain akan berjalan sehingga bunyi selesai.
Butang + di sebelah waveform membuka Sound Effect Editor.
Dalam editor tersebut, cikgu boleh:
✔️ Menambah beberapa lapisan bunyi
✔️ Melakar bentuk gelombang
✔️ Menukar pitch naik turun
✔️ Mengubah envelope (serang – sustain – decay)
✔️ Membuat bunyi robot, siren, laser, air, burung, UI beep dan banyak lagi
Ini menjadikan micro:bit V2 sangat sesuai untuk:
projek robot
animasi
permainan mini
bunyi notifikasi
bunyi reaksi (reaction sound)
Semua kod lain dihentikan sehingga bunyi selesai.
Bunyi = 500ms
Program berhenti 0.5 saat.
Jika mahu bunyi berjalan serentak dengan kod lain → gunakan in background.
Contoh:
play soundEffect until done
basic.showIcon(IconNames.Heart)
Urutannya ialah:
Bunyi dimainkan
Tunggu sampai selesai
Papar ikon Heart
Tidak berlaku serentak.
music.playSoundEffect(soundExpression.laser, SoundExpressionPlayMode.UntilDone)
input.onButtonPressed(Button.A, function () {
music.playSoundEffect(mySound, SoundExpressionPlayMode.UntilDone)
})
basic.showIcon(IconNames.Happy)
music.playSoundEffect(mySmileSound, SoundExpressionPlayMode.UntilDone)
for (let i = 0; i < 5; i++) {
music.playSoundEffect(stepSound, SoundExpressionPlayMode.UntilDone)
}
while (input.soundLevel() > 180) {
music.playSoundEffect(siren, SoundExpressionPlayMode.UntilDone)
}
👉 Blok ini memainkan bunyi yang cikgu/ murid reka sendiri dalam Sound Editor. “Until done” bermaksud program tunggu bunyi habis sebelum sambung kod lain.
Blok sound effect object—iaitu satu bentuk bunyi yang boleh diedit menggunakan Sound Editor dalam MakeCode.
Blok ini tidak memainkan bunyi secara langsung.
Sebaliknya, ia adalah data bunyi yang digunakan di dalam blok lain seperti:
play sound …
play … until done
play … in background
Blok ini mewakili sound effect yang boleh cikgu reka sendiri.
Ia menyimpan semua maklumat bunyi:
✔ pitch (frekuensi)
✔ perubahan pitch (naik/turun)
✔ waveform (jenis gelombang)
✔ volume
✔ panjang bunyi (duration)
✔ envelope (attack, sustain, decay)
✔ vibrato
✔ echo
✔ kesan khas bunyi
Ini adalah bunyi custom yang kita cipta sendiri menggunakan sound editor micro:bit V2.
Butang + membuka Sound Effect Editor.
Di dalam editor, cikgu boleh:
Tarik garisan gelombang ke atas/bawah.
sine
square
sawtooth
noise
attack (permulaan bunyi)
sustain (tahan bunyi)
release (melemah)
vibrato
echo
tremolo
distortion
Seolah-olah melukis lengkung bunyi di atas timeline.
Hasilnya → menjadi sound effect custom yang sangat unik!
Blok ini digunakan di dalam blok “play sound effect” seperti ini:
play [sound effect] until done
play [sound effect] in background
input.onButtonPressed(Button.A, function () {
music.playSoundEffect(mySiren)
})
Boleh sambungkan bunyi custom kepada LED animation atau servo.
music.playSoundEffect(myLaser, SoundExpressionPlayMode.UntilDone)
for (let i = 0; i < 5; i++) {
music.playSoundEffect(stepFX)
}
input.onLogoEvent(TouchButtonEvent.Pressed, function () {
music.playSoundEffect(customGiggle)
})
✔ Lebih kreatif
✔ Tak terhad kepada bunyi preset
✔ Sound effect boleh dibuat ikut tema (robot, game, alarm, bunyi haiwan)
✔ Sangat sesuai untuk:
projek robot
animasi micro:bit
permainan LED
sistem amaran
projek STEM interaktif
👉 Blok ini ialah sound effect custom. Ia digunakan untuk mencipta dan menyimpan bunyi unik melalui Sound Editor micro:bit V2. Butang ‘+’ membuka editor tersebut. Bunyi ini kemudian digunakan dalam blok ‘play sound effect’.
Blok ini ialah blok Boolean (True/False) yang digunakan untuk menyemak sama ada micro:bit sedang memainkan sebarang bunyi atau tidak.
Ia akan memulangkan:
TRUE → jika ada bunyi sedang dimainkan
FALSE → jika tiada bunyi dimainkan
Blok ini mengesan semua jenis bunyi yang dimainkan melalui micro:bit V2, termasuk:
giggle
happy
sad
slide
twinkle
jump
power up / power down
(suara yang murid reka sendiri)
dadadum
entertainer
chase
birthday
ringtone
ring tone (Hz)
play tone … for … beat
Blok ini tidak mengesan bunyi dari luar, contohnya:
✖ bunyi microphone input
✖ bunyi dari sekeliling
✖ bunyi peranti lain
Blok ini hanya mengesan bunyi micro:bit yang sedang dimainkan, bukan bunyi luar.
Kerana ia membolehkan kita:
✔ Menunggu bunyi habis sebelum buat aksi lain
✔ Mengelakkan main bunyi bertindih (overlapping audio)
✔ Membina game muzik
✔ Mengawal robot berdasarkan status audio
✔ Membuat animasi ikut bunyi
Blok ini biasanya digunakan dalam:
if (music.isSoundPlaying()) {
basic.showIcon(IconNames.Heart)
}
Tunggu bunyi habis:
while (music.isSoundPlaying()) {
basic.pause(10)
}
basic.showString("Done!")
if (!(music.isSoundPlaying())) {
music.playSoundEffect(sounds.jump)
}
Hanya main bunyi jika tiada bunyi lain sedang main.
while (music.isSoundPlaying()) {
basic.showIcon(IconNames.Happy)
}
basic.clearScreen()
if (!(music.isSoundPlaying())) {
music.playSoundEffect(sounds.jump)
}
if (!(music.isSoundPlaying())) {
music.playSoundEffect(siren)
}
music.playSoundEffect(effect)
while (music.isSoundPlaying()) {}
motors.forward(100)
👉 “sound is playing” ialah blok yang memberitahu sama ada micro:bit sedang berbunyi atau tidak.
Jika bunyi sedang dimainkan → TRUE
Jika tiada bunyi → FALSE
Blok ini digunakan untuk menghidupkan atau mematikan speaker terbina (built-in speaker) pada micro:bit V2.
Dalam gambar cikgu, pilihan yang dipilih ialah:
→ Speaker terbina dimatikan dan micro:bit tidak akan menghasilkan bunyi melalui speaker onboard.
Hanya micro:bit V2 mempunyai speaker terbina di bahagian belakang papan.
Ia boleh memainkan melodi
sound effects
nada (tone)
bunyi custom dari editor
ringtone
Speaker ini digunakan secara automatik jika cikgu tidak sambung buzzer luaran.
Blok ini:
ON → bunyi kedengaran
OFF → bunyi tidak keluar (mute)
Kalau cikgu sambung buzzer di P0:
Speaker OFF → buzzer masih boleh berbunyi
Speaker ON → buzzer juga boleh berbunyi melalui pin
Ada beberapa situasi penting:
Jika projek robot atau projek elektronik menggunakan piezo buzzer, kita perlu mematikan speaker bawaan micro:bit.
set built-in speaker OFF
pins.analogWritePin(AnalogPin.P0, 512)
Supaya bunyi keluar dari buzzer, bukan dari papan micro:bit.
Contoh:
projek senyap dalam kelas
mod “silent mode”
mod “night mode”
permainan tanpa bunyi
aktiviti makmal yang tidak boleh bising
set built-in speaker OFF
Contoh:
micro:bit menghantar signal PWM ke speaker kecil melalui pin P0
micro:bit sambung ke amplifier luaran
projek IoT yang benarkan audio luaran sahaja
Speaker terbina akan ganggu jika tidak dimatikan.
✖ Tiada bunyi keluar walaupun:
play tone dijalankan
play melody dijalankan
play sound effect dijalankan
ring tone dijalankan
✔ Tetapi bunyi di output pin (P0, P1, P2) masih aktif.
Guna:
set built-in speaker ON
Selepas ON, semua bunyi akan kembali semula melalui speaker terbina.
music.setBuiltInSpeakerEnabled(false)
pins.analogWritePin(AnalogPin.P0, 512)
input.onButtonPressed(Button.B, function () {
music.setBuiltInSpeakerEnabled(false)
})
if (input.isGesture(Gesture.Shake)) {
music.setBuiltInSpeakerEnabled(true)
music.playMelody("C D E F G", 120)
}
👉 Blok ini menghidupkan atau mematikan speaker terbina dalam micro:bit V2. Bila OFF → micro:bit tidak berbunyi, tetapi buzzer luaran masih boleh berfungsi.
Icon LED yang cikgu tunjuk itu adalah kategori dalam MakeCode, bukan satu blok.
Kategori ini mengawal 5×5 LED matrix yang ada pada bahagian depan micro:bit.
Semua blok di bawah kategori ini digunakan untuk:
Berikut adalah fungsi utama dalam kategori LED:
Blok: plot x y
Menyalakan LED pada koordinat tertentu.
Contoh: plot 0 0 menyalakan LED di sudut kiri atas.
Digunakan untuk:
Membuat corak
Animasi
Objek bergerak (contoh: game pixel)
Blok: unplot x y
Mematikan LED pada lokasi tertentu
Digabungkan dengan plot untuk membuat pergerakan.
Blok: point x y
Menyemak sama ada LED pada koordinat itu ON atau OFF
Berguna untuk logik permainan (game programming)
Blok: toggle x y
Jika LED OFF → akan ON
Jika LED ON → akan OFF
Seperti suis “ON/OFF”.
Blok:
set brightness
change brightness by
set display mode
Fungsi:
Ubah tahap terang LED (0–255)
Sesuai untuk buat “fade in / fade out”
Mode biasa atau mode low power
Blok: clear screen
Mematikan semua LED sekaligus
Membersihkan paparan sebelum memaparkan data seterusnya
Blok: show icon
Papar ikon sedia ada seperti ❤️, 😊, ✔️, ❌
Bebas pilih ikon dari menu
Blok: show leds
Membolehkan murid melukis bentuk sendiri
Contoh: rumah, smiley, bintang
Guna 5×5 grid
Gabungan:
plot → pause → unplot → pause
Membuat animasi seperti berjalan, berkelip, bergerak.
Kategori LED digunakan untuk mengawal lampu LED pada micro:bit.
Kita boleh hidupkan LED, padam LED, lukis gambar, buat animasi dan laraskan kecerahan.
Semua yang melibatkan cahaya micro:bit, ada dalam kategori LED.
Blok ini digunakan untuk menyalakan (turn ON) satu LED pada grid LED micro:bit berdasarkan koordinat X dan Y.
Blok ini akan:
✔ Menyalakan LED tertentu pada papan micro:bit
✔ Berdasarkan lokasi LED menggunakan sistem koordinat (X, Y)
✔ Mengubah LED daripada mati → menyala
✔ Tidak memadam LED lain (ia hanya hidupkan satu titik)
Micro:bit ada 25 LED disusun dalam grid 5 kolum × 5 baris.
Contoh:
plot x 0 y 0
👉 LED paling atas kiri menyala.
plot x 2 y 3
👉 LED di kolum 2, baris 3 menyala.
led.plot(2, 2)
LED tengah menyala.
for (let i = 0; i <= 4; i++) {
led.plot(i, 2)
basic.pause(200)
}
LED bergerak dari kiri ke kanan.
led.plot(input.acceleration(Dimension.X), input.acceleration(Dimension.Y))
for (let x = 0; x <= 4; x++) {
for (let y = 0; y <= 4; y++) {
led.plot(x, y)
}
}
Semua LED hidup → skrin penuh.
let x = 2
let y = 2
led.plot(x, y)
✔ Hanya menyala LED — tidak memadam (gunakan unplot)
✔ Jika koordinat di luar julat 0–4 → tiada LED menyala
✔ Sentiasa koordinat integer (nombor bulat)
👉 Blok plot x y menyalakan satu titik LED pada lokasi yang cikgu tentukan dalam grid 5×5 micro:bit. X bergerak kiri–kanan, Y bergerak atas–bawah.
Blok toggle digunakan untuk menukar keadaan LED pada koordinat tertentu dalam grid 5×5 micro:bit.
Maknanya:
👉 Jika LED menyala, blok ini akan memadamkannya
👉 Jika LED padam, blok ini akan menyalakannya
Ia berfungsi seperti suis ON/OFF automatik.
Blok ini:
✔ Mengesan status LED pada lokasi (x, y)
✔ Jika LED = OFF → jadikan ON
✔ Jika LED = ON → jadikan OFF
✔ Tidak mengganggu LED lain
Ia memberi fungsi “flip” atau “tukar keadaan”.
Contoh:
Jika LED atas kiri:
menyala → padam
padam → menyala
LED pada koordinat itu akan bertukar keadaan.
toggle x 2 y 2
basic.pause(200)
LED tengah akan berkelip setiap ulang.
input.onButtonPressed(Button.A, function () {
led.toggle(2, 2)
})
Setiap tekan → LED tengah berubah ON/OFF.
for (let x = 0; x <= 4; x++) {
led.toggle(x, 2)
basic.pause(150)
}
LED di baris tengah akan ON/OFF secara berurutan.
let x = Math.randomRange(0, 4)
let y = Math.randomRange(0, 4)
led.toggle(x, y)
Lampu rawak menyala atau padam — sesuai untuk mini game.
Contoh: Toggle LED bila mikrofon kesan bunyi kuat.
if (input.soundLevel() > 160) {
led.toggle(4, 4)
}
Toggle membolehkan murid lukis dan padam titik LED seperti melukis di papan grafik.
Blok
Kegunaan
plot
Menyalakan LED
unplot
Memadam LED
toggle
Menukar keadaan ON ↔ OFF
plot brightness
Menentukan tahap kecerahan
Toggle paling fleksibel sebab tidak perlu tahu LED sedang ON atau OFF.
👉 Blok toggle x y menukar keadaan LED pada koordinat itu. Jika menyala, ia padam. Jika padam, ia menyala. Seperti suis ON/OFF automatik untuk LED tertentu.
Blok ini digunakan untuk memadam (turn OFF) LED tertentu pada grid 5×5 micro:bit berdasarkan koordinat X dan Y.
Jika LED pada lokasi itu sedang menyala, ia akan dipadam.
Jika LED sudah padam, tiada apa yang berlaku.
Blok ini:
✔ Memadamkan LED pada koordinat tertentu
✔ Mengawal paparan LED secara tepat
✔ Tidak menjejaskan LED lain
✔ Menjadikan LED kembali pada keadaan OFF (0)
Digunakan bersama blok plot, toggle, dan plot brightness untuk menghasilkan visual, animasi atau paparan interaktif.
Micro:bit mempunyai 25 LED dalam grid 5 kolum × 5 baris.
Julat nilai: 0 – 4
Julat nilai: 0 – 4
Contoh:
unplot x 0 y 0
→ LED paling atas kiri dimatikan.
unplot x 2 y 3
→ LED di kolum 2, baris 3 dipadam.
Jika LED itu tidak menyala, tiada perubahan berlaku (tetap OFF).
led.plot(2, 2)
basic.pause(500)
led.unplot(2, 2)
for (let x = 0; x <= 4; x++) {
led.plot(x, 2)
basic.pause(150)
led.unplot(x, 2)
}
LED menyala, kemudian dipadam semula untuk memberi kesan bergerak.
for (let x = 0; x <= 4; x++) {
for (let y = 0; y <= 4; y++) {
led.unplot(x, y)
}
}
Dengan butang A = plot, B = unplot.
input.onButtonPressed(Button.B, function () {
led.unplot(cursorX, cursorY)
})
Padamkan objek yang bergerak setelah dilukis.
👉 Blok unplot x y memadam LED pada lokasi tertentu dalam grid 5×5 micro:bit. Ia memastikan LED itu OFF tanpa menjejaskan LED lain.
Blok point x y digunakan untuk menyemak (check) sama ada LED pada kedudukan tertentu dalam grid micro:bit sedang menyala (ON) atau padam (OFF).
Blok ini tidak menyalakan atau memadam LED.
Sebaliknya, ia memberi nilai keputusan:
TRUE (benar) → LED itu menyala
FALSE (palsu) → LED itu padam
Blok ini digunakan dalam kondisi IF, loop, dan logik untuk membaca status LED pada skrin micro:bit.
✔ Memeriksa LED tertentu sedang ON atau OFF
✔ Mengembalikan nilai Boolean: true atau false
✔ Membantu kawal animasi, permainan, dan pergerakan objek
✔ Penting untuk projek pixel checking, collision detection, animation frame, dan drawing tools
Micro:bit ada 25 LED dalam grid:
X → kolum (0 hingga 4)
Y → baris (0 hingga 4)
LED (0,0) = titik paling atas kiri
LED (4,4) = titik paling bawah kanan
Contoh:
point x 2 y 1
Jika LED (2,1) menyala → blok ini pulangkan TRUE
Jika LED padam → blok ini pulangkan FALSE
if (led.point(2, 2)) {
basic.showString("ON")
} else {
basic.showString("OFF")
}
if (led.point(nextX, nextY)) {
gameOver = true
}
Jika LED depan ular sudah menyala, itu bermakna ular langgar badan sendiri.
if (led.point(ballX, ballY + 1)) {
direction = -1
}
Digunakan dalam permainan bola memantul.
Butang A = nyala LED
Butang B = padam LED
Logo = semak LED
if (led.point(cursorX, cursorY)) {
basic.showIcon(IconNames.Yes)
} else {
basic.showIcon(IconNames.No)
}
Semak LED untuk menentukan frame animasi seterusnya.
👉 Blok point x y digunakan untuk memeriksa LED pada koordinat itu sama ada ON atau OFF. Ia tidak ubah LED, cuma bagi jawapan TRUE atau FALSE.
Blok ini digunakan untuk memaparkan graf bar (bar graph) pada LED matrix 5×5 micro:bit berdasarkan sesuatu nilai semasa berbanding nilai maksimum.
Ia adalah salah satu cara paparan visual untuk menunjukkan:
bacaan sensor
nilai pembolehubah
tahap bunyi
tingkat suhu
skor permainan
data pergerakan (acceleration)
Paparan graf ini membantu murid melihat nilai dalam bentuk visual, bukan nombor.
✔ Memaparkan graf bar menegak di skrin micro:bit
✔ Menggunakan antara 0 hingga 25 LED untuk menunjukkan nilai
✔ Menjadikan pembacaan sensor lebih mudah difahami
✔ Skala bar graph akan berubah secara automatik berdasarkan nilai maksimum yang ditetapkan
✔ Boleh digunakan dalam ulangan (loop) untuk paparan masa nyata (real-time)
Blok mempunyai dua bahagian:
Ini ialah nilai yang micro:bit mahu paparkan dalam bentuk graf
Contoh: suhu, sound level, skor, jarak, acceleration
Ini ialah nilai paling tinggi bagi skala graf
Bila nilai semasa mencapai nilai maksimum → graf akan penuh 5 baris
Skrin micro:bit mempunyai 25 LED (5 baris × 5 lajur).
Bar graph akan menyala mengikut:
Bilangan LED Menyala = (nilai semasa / nilai maksimum) × 25
Contoh:
plot bar graph of 50 up to 100
Nilai semasa = 50
Nilai maksimum = 100
50/100 = 0.5
0.5 × 25 = 12.5
→ Micro:bit akan menyalakan kira-kira 12 LED (2 setengah lajur)
plot bar graph of soundLevel up to 255
Bunyi kuat = graf tinggi
Bunyi perlahan = graf rendah
plot bar graph of acceleration(Dimension.X) up to 1023
Boleh digunakan dalam projek shake monitor atau step counter.
plot bar graph of input.temperature() up to 40
Kalau suhu 30°C → lebih kurang 75% LED menyala.
plot bar graph of score up to 10
Skor naik → bar graph semakin penuh.
plot bar graph of counter up to 50
Counter = 25 → graf separuh.
Biasanya blok ini digunakan dalam forever:
basic.forever(function () {
plotBarGraph(input.soundLevel(), 255)
})
→ Bar graph akan bergerak secara live mengikut input.
Graf akan naik dari bawah ke atas, kiri ke kanan
Nilai negatif tidak dipaparkan (akan dianggap 0)
Jika nilai semasa > nilai maksimum → graf PENUH
Paparan LED lain akan hilang bila graf dipaparkan (LED overwrite)
👉 Blok ini tunjuk nilai dalam bentuk graf bar LED. Lagi besar nilai, lagi banyak LED menyala. Nilai tertinggi ikut angka ‘up to’.
Blok ini digunakan untuk menyalakan LED tertentu pada grid LED 5×5 micro:bit dengan kawalan tahap kecerahan (brightness) mengikut nilai yang kita tetapkan.
Ini adalah versi lebih advanced berbanding blok plot x y biasa.
✔ Menyalakan LED pada koordinat (x, y)
✔ Kita boleh tentukan kecerahan LED (0–255)
✔ Kecerahan 255 = paling terang
✔ Kecerahan 0 = LED padam
✔ Sesuai untuk membuat animasi, bayang-bayang, grafik, atau paparan data yang lebih kreatif
Micro:bit menggunakan grid LED 5×5:
x = kedudukan mendatar (0 hingga 4)
y = kedudukan menegak (0 hingga 4)
Contoh:
Lokasi
Koordinat
LED paling atas kiri
(0,0)
LED paling atas kanan
(4,0)
LED paling bawah kiri
(0,4)
LED tengah
(2,2)
Kecerahan ditetapkan antara:
0–255
255 → LED paling terang
128 → separuh terang
50 → sangat malap
0 → padam (sama seperti unplot)
LED micro:bit sebenarnya menyokong "PWM brightness" – LED akan berkelip laju untuk menghasilkan kesan terang/malap.
for (let b = 0; b <= 255; b = b + 5) {
led.plotBrightness(2, 2, b)
basic.pause(10)
}
LED tengah semakin terang sedikit demi sedikit.
led.plotBrightness(0, 0, input.soundLevel())
→ Bunyi kuat = LED lebih terang
→ Bunyi perlahan = LED malap
LED disusun mengikut kecerahan berbeza untuk hasil grafik lebih menarik.
Seperti:
led.plotBrightness(2, 0, input.temperature() * 5)
Jika x atau y di luar julat 0–4 → LED tidak akan menyala
Jika brightness < 0 atau > 255 → sistem akan clamp kepada 0 atau 255
Kecerahan tinggi guna lebih kuasa (penting jika pakai bateri)
👉 Blok ini menyalakan LED tertentu dengan kecerahan yang kita pilih (0–255). Semakin besar nombor, semakin terang LED. Sesuai untuk animasi, sensor atau grafik.
Blok ini digunakan untuk menyemak tahap kecerahan LED tertentu pada grid LED 5×5 micro:bit.
✦ Ia TIDAK menyalakan LED
✦ Ia hanya membaca (check) berapa terang LED tersebut
Blok ini mengembalikan nilai nombor (0–255), iaitu tahap kecerahan LED pada kedudukan (x, y).
✔ Membaca tahap kecerahan LED pada koordinat tertentu
✔ Digunakan untuk pengaturcaraan logik, contohnya:
untuk tahu sama ada LED sedang menyala
untuk dapatkan nilai brightness LED yang digunakan bagi animasi
untuk membaca semula keadaan papan LED dalam sesuatu grafik
✔ Blok ini mengembalikan nilai brightness, bukan True/False.
LED micro:bit mempunyai nilai kecerahan antara:
0 → LED padam
1–254 → LED malap hingga terang sederhana
255 → LED paling terang
Jika LED tidak dinyalakan langsung, nilai biasa = 0.
Jika LED dinyalakan menggunakan plot x y, brightness biasanya 255.
Jika dinyalakan dengan plot brightness, nilainya bergantung pada tetapan.
Grid LED micro:bit adalah 5 lajur × 5 baris:
| X (mendatar) | 0 → 4 |
| Y (menegak) | 0 → 4 |
Contoh LED:
(0,0) = LED paling atas kiri
(4,0) = atas kanan
(0,4) = bawah kiri
(2,2) = tengah
Jika koordinat di luar julat, nilai brightness = 0 (kerana LED itu tidak wujud).
if (led.pointBrightness(2, 2) > 0) {
basic.showString("ON")
} else {
basic.showString("OFF")
}
Jika LED tengah menyala, paparkan "ON".
Contohnya, LED menjadi semakin terang ikut kiraan:
let b = led.pointBrightness(2, 2)
led.plotBrightness(2, 2, b + 20)
Pemeriksaan kecerahan LED lain berguna untuk efek seperti:
bola bergerak dan memantul
objek "bertumbuk" dengan LED lain
Kadang-kadang kita buat animasi daripada fungsi rawak (random).
Blok ini membolehkan kita "membaca balik" kecerahan LED untuk logik seterusnya.
👉 Blok ini membaca tahap kecerahan (0–255) LED di lokasi X dan Y. Ia tidak menyalakan LED tetapi hanya memberi nilai brightness untuk logik atau animasi lanjutan.
Blok brightness digunakan untuk membaca atau mendapatkan nilai kecerahan LED yang sedang aktif pada semasa operasi tertentu dalam micro:bit.
⚠️ Penting:
Blok ini bukan untuk menetapkan kecerahan LED.
Ia hanya untuk mendapatkan nilai kecerahan semasa (brightness value).
Nilai brightness sentiasa berada dalam julat:
0 → LED gelap (OFF)
1–254 → LED malap hingga sederhana terang
255 → LED paling terang (FULL BRIGHTNESS)
Biasanya blok brightness digunakan dalam blok lain seperti:
let b = led.brightness()
led.plotBrightness(2, 2, b)
Ini akan menggunakan nilai brightness semasa sebagai intensiti LED.
Membina animasi fade-in atau fade-out
Menggunakan nilai brightness LED sebelumnya sebagai rujukan
Mencipta kesan “naik turun cahaya”
for (let i = 0; i <= 255; i += 25) {
led.plotBrightness(2, 2, i)
basic.pause(50)
}
Di sini brightness boleh digunakan untuk membaca semula intensiti LED semasa.
let b = led.brightness()
led.plotBrightness(2, 2, b + 20)
LED akan semakin cerah setiap kali loop berjalan.
let b = led.brightness()
led.plotBrightness(3, 3, b)
LED (3,3) akan menyamai kecerahan LED semasa.
👉 Blok brightness mengambil nilai tahap kecerahan (0–255) LED yang sedang digunakan, untuk digunakan dalam pengiraan, animasi, atau operasi lanjutan. Ia TIDAK mengawal LED — hanya membaca nilai brightness sahaja.
Blok ini digunakan untuk menetapkan tahap kecerahan LED pada keseluruhan paparan micro:bit.
Ia bukan menetapkan brightness satu LED sahaja, tetapi mengubah brightness default untuk SEMUA LED yang akan dipapar selepas arahan ini.
0 → LED gelap sepenuhnya (off)
1–254 → LED malap hingga sederhana terang
255 → LED paling terang maksimum
Nilai 255 dalam gambar bermaksud LED akan dipaparkan pada kecerahan tertinggi.
Selepas ditetapkan, setiap LED yang dinyalakan menggunakan blok lain seperti:
plot x y
plot bar graph
show icon
show leds
scroll string
…semuanya akan menggunakan tahap brightness yang ditentukan.
Contoh:
set brightness 50
basic.showIcon(IconNames.Heart)
→ Semua LED dalam bentuk hati akan kelihatan malap.
Micro:bit LED yang terlalu terang cepat guna bateri.
set brightness 20
basic.showString("HELLO")
LED lebih malap → jimat tenaga.
for (let i = 0; i <= 255; i += 10) {
led.setBrightness(i)
basic.showIcon(IconNames.Heart)
basic.pause(50)
}
Hati akan menyala semakin terang sedikit demi sedikit.
Jika micro:bit digunakan dalam bilik gelap:
set brightness 100
Paparan lebih selesa untuk mata pelajar.
👉 Blok set brightness digunakan untuk mengawal tahap kecerahan keseluruhan paparan LED micro:bit antara 0–255.
👉 Nilai tinggi = terang, nilai rendah = malap.
Blok led enable digunakan untuk menghidupkan atau mematikan keseluruhan paparan LED micro:bit.
Pilihan nilai:
true → LED dihidupkan (paparan berfungsi seperti biasa)
false → LED dimatikan sepenuhnya (tiada LED akan menyala)
Dalam gambar, blok menunjukkan led enable false
➡️ Semua LED micro:bit akan dimatikan dan tidak memaparkan apa-apa.
Tiada LED akan:
menyala
memaparkan ikon
memaparkan teks
memplot graf
scroll string
Walaupun ada kod untuk menyala LED, output tidak akan muncul selagi led enable false masih aktif.
LED micro:bit menggunakan tenaga paling banyak. Mematikan LED:
sangat menjimatkan bateri
sesuai untuk projek luar kelas atau prototaip jangka panjang
Dalam projek yang fokus kepada:
bunyi
sensor
input butang
output pada servo atau motor
LED tidak diperlukan → jadi ia dimatikan untuk lebih kemas.
Kadang-kadang pelajar membuat projek:
robot
kenderaan
sistem alarm
dan paparan LED mengganggu. Maka LED dimatikan.
Semua fungsi LED berhenti.
plot
show icon
show number
scroll string
dan lain-lain
→ semuanya tidak akan muncul.
Kod lain tetap berjalan seperti biasa.
Bunyi
Radio
Pin digital
Servo
Motor
→ semua ini berjalan tanpa masalah.
LED akan berfungsi semula hanya jika:
led enable true
dijalankan.
Robot menggunakan sensor IR, motor, servo. LED tidak diperlukan.
led enable false
// robot start moving
Hanya bunyi penting, LED boleh dimatikan.
on loud sound
led.enable(false)
music.playSound(Sounds.Giggle)
Merekod data suhu setiap minit. Untuk jimat bateri:
led enable false
👉 led enable false = matikan paparan LED seluruhnya
👉 Jimat bateri, elak gangguan visual, sesuai untuk projek robotik atau sistem sensor
👉 Untuk hidupkan semula: led enable true
Blok stop animation digunakan untuk memberhentikan serta-merta apa-apa animasi LED yang sedang berjalan pada paparan micro:bit.
Animasi yang dihentikan termasuk:
show animation
show leds berulang
ikon atau gambar yang sedang bertukar-tukar
teks yang sedang scroll
apa sahaja paparan LED yang memaparkan siri pergerakan secara automatik
Tujuan blok ini:
➡️ Menghentikan animasi LED yang sedang berlangsung supaya micro:bit dapat memaparkan arahan visual yang baharu dengan segera.
Dalam MakeCode, animasi LED terjadi apabila:
kod memaparkan imej secara bergilir-gilir
teks sedang berjalan (scrolling)
imej berubah berulang tanpa henti
fungsi paparan tidak selesai sepenuhnya
loop sedang memaparkan LED secara rapid
Contoh animasi:
basic.showString("HELLO")
→ Selepas kod ini berjalan, micro:bit sibuk scrolling huruf satu per satu.
Jika anda panggil stop animation, teks yang sedang berjalan akan terus berhenti.
Semua perubahan paparan LED berhenti, dan LED akan kekal pada keadaan terakhir sebelum berhenti.
Contoh:
basic.showString("HELLO")
stop animation
basic.showIcon(IconNames.Heart)
→ Teks “HELLO” berhenti serta-merta, dan ikon hati muncul terus.
teks berjalan
imej bergerak kiri → kanan
animasi loading
bar graph yang auto-scroll
animasi berulang dalam while atau forever
stop animation tidak menghentikan:
bunyi
input butang
radio
sensor (acceleration, compass, sound, light)
servo atau motor
loop forever (kod tetap berjalan)
Hanya animasi LED yang dihentikan.
Contoh: murid tekan butang untuk tunjuk ikon segera
Jika animasi panjang masih berjalan, paparan baharu akan lambat muncul.
Jadi, kita hentikan dahulu:
stop animation
basic.showIcon(IconNames.Yes)
Robot memerlukan paparan LED cepat bertukar mengikut keadaan.
Tanpa stop animation, teks/animasi lama boleh ganggu.
Untuk menghentikan animasi kalah/menang yang sedang berjalan
dan terus tukar ke paparan baharu.
input.onSound(DetectedSound.Loud, function () {
stopAnimation()
basic.showIcon(IconNames.Surprised)
})
stop animation
basic.showIcon(IconNames.Skull)
👉 stop animation = Berhenti semua animasi LED serta-merta
👉 Digunakan bila kita mahu paparan baharu muncul cepat
👉 Tidak menjejaskan bunyi atau input lain
👉 Sangat berguna dalam projek animasi, game, atau respon pantas
Blok ini digunakan untuk menetapkan cara paparan LED micro:bit memaparkan cahaya — sama ada:
Black and White (Hitam & Putih)
Greyscale (Kelabu – pelbagai tahap kecerahan)
Dalam gambar, pilihan ialah:
Ini bermaksud paparan micro:bit akan berfungsi dalam mod monokrom:
LED hanya ada dua keadaan:
ON (menyala)
OFF (padam)
Tiada lagi kecerahan malap, sederhana, atau terang.
Dalam mod ini:
plot x y brightness 180
set brightness 50
…semua akan ditukar kepada ON = 1 (menyala) atau OFF = 0 (padam).
Setiap LED hanya ada dua status sahaja, seperti pixel hitam & putih.
Kerana micro:bit tidak perlu mengurus nilai kecerahan.
micro:bit mempunyai LED 5×5 yang boleh dimalapkan.
Namun, sesetengah projek tidak memerlukan brightness, jadi mod “black and white” memberi kelebihan:
Tanpa brightness tinggi atau interpolasi cahaya → penggunaan tenaga lebih rendah.
Sesuai untuk animasi atau permainan yang memerlukan respon cepat.
Game pixel (Snake, Pong, Shooting) lebih konsisten.
Mudah untuk ajar konsep ON/OFF sahaja.
ikon seperti heart, smiley, arrow
teks scroll
graf bar simple
animasi ON/OFF basic
brightness berbeza
efek fade in / fade out
plot x y brightness nilai
set brightness nilai
LED gradient
→ Semua ini akan diabaikan.
set display mode black and white
set brightness 20
basic.showIcon(IconNames.Heart)
HATI tetap menyala penuh (tiada malap), kerana brightness tidak digunakan.
set display mode black and white
basic.showString("HELLO")
Teks berjalan dengan LED sepenuhnya ON/OFF sahaja.
set display mode black and white
led.plot(2, 2)
basic.pause(100)
led.unplot(2, 2)
Pergerakan pixel lebih laju & jelas.
Jika dropdown ditukar kepada:
→ paparan menyokong 0–255 brightness (lebih realistik, tapi lebih berat & guna bateri)
👉 set display mode black and white menjadikan LED hanya ON atau OFF, tanpa kecerahan.
👉 Sesuai untuk game, animasi pantas, dan projek jimat bateri.
👉 Menyebabkan fungsi brightness lain diabaikan.
Icon Radio ini adalah kategori blok yang digunakan untuk:
menggunakan gelombang radio jarak dekat (± 10–30 meter bergantung keadaan).
Fungsi ini hanya wujud bila:
micro:bit berada dalam kumpulan channel yang sama
kedua-dua micro:bit mengaktifkan fungsi radio
Menetapkan “channel”.
Semua micro:bit mesti gunakan nombor group yang sama untuk berkomunikasi.
Contoh:
Group 1 = Team A
Group 5 = Team B
Group 17 = Robot Controller
Jika group tak sama → tak boleh hantar mesej.
Menghantar nombor seperti:
1
99
suhu
nilai sensor
status (0 = OFF, 1 = ON)
Sangat penting untuk:
kawal robot
kawal LED micro:bit lain
hantaran data sensor
Menghantar perkataan seperti:
“Hello”
“Start”
“Awas!”
Digunakan untuk:
sistem mesej
komunikasi guru-murid
permainan multiplayer
Format:
("suhu", 28)
("jarak", 50)
Digunakan untuk projek IoT / paparan data:
cuaca
jarak
bunyi
air
kadar denyutan (simulasi)
Blok ini akan aktif bila micro:bit menerima mesej.
Apa sahaja yang diletakkan dalam blok ini akan berjalan automatik bila mesej diterima.
Contoh:
Terima nombor 1 → hidupkan LED
Terima string “go” → robot mula berjalan
Blok bacaan data radio:
receivedNumber
receivedString
receivedName
receivedValue
Ini membolehkan penerima bertindak balas mengikut jenis data.
Nilai 0 – 7
Lebih tinggi = lebih jauh jarak penghantaran
Lebih rendah = jimat bateri
Digunakan untuk mengelakkan gangguan jika terdapat banyak micro:bit di satu kawasan ramai murid.
Untuk projek lanjutan:
mikrobit → komputer → paparan graf
debugging data radio
IoT kelas menengah
“Kategori Radio digunakan untuk hantar & terima mesej tanpa wayar antara micro:bit.
Ia macam ‘walkie-talkie’ kecil — boleh hantar nombor, teks atau data sensor.
Tetapi mesti dalam group yang sama barulah micro:bit boleh ‘bercakap’.”
Blok ini digunakan untuk menetapkan kumpulan (group) komunikasi radio micro:bit.
Dalam contoh gambar:
👉 radio set group 1
Ini bermaksud micro:bit anda akan berkomunikasi menggunakan Group 1.
Radio group ialah saluran komunikasi yang menentukan micro:bit mana boleh berhubung antara satu sama lain.
Micro:bit yang berada dalam group yang sama → boleh hantar dan terima mesej sesama sendiri.
Micro:bit dalam group berbeza → tidak akan menerima mesej antara satu sama lain.
Group radio = seperti channel walkie-talkie
📡 Jika semua set kepada Channel 1 → semua boleh berbual
📡 Jika satu set ke Channel 2 → dia tidak dengar apa-apa
Nilai group yang boleh dipilih:
➡ 0 hingga 255
Jika banyak kumpulan pelajar guna mikrobit dalam kelas:
Kumpulan A → group 1
Kumpulan B → group 2
Kumpulan C → group 3
Mereka tidak akan menerima mesej antara satu sama lain.
Semua arahan radio lain bergantung kepada group ini:
radio send number
radio send string
radio send value
on radio received
Semua ini hanya berfungsi dalam group yang sama.
Tanpa menetapkan kumpulan:
micro:bit mungkin berada dalam group default (0)
Mesej mudah bercampur dalam satu bilik kelas
Projek mengawal robot boleh menerima signal dari kelompok lain → kacau!
Sebab itu SET GROUP ialah langkah pertama dalam mana-mana projek radio.
Micro:bit A:
radio set group 5
radio.sendString("Hello!")
Micro:bit B:
radio.setGroup(5)
on radio received string → show string
Kedua-duanya akan berhubung melalui Group 5.
Remote:
radio set group 12
radio.sendValue("motor", 1)
Robot:
radio set group 12
on radio received value → kawal motor
Player 1,2,3 semua set ke group 7
→ Boleh menghantar skor, nyawa, atau event game sesama mereka.
❌ Hantar radio, tetapi lupa set group → tiada micro:bit menerima mesej
❌ Dua kumpulan pelajar pilih group yang sama → mesej bercampur
❌ Guna group terlalu kecil (contoh: semua guna group 1)
👉 radio set group menentukan saluran komunikasi antara micro:bit.
👉 micro:bit hanya berhubung dengan micro:bit lain dalam group yang sama.
👉 Sangat penting untuk projek seperti remote robot, multiplayer game, sensor beacon, messaging, dan banyak lagi.
Blok ini digunakan untuk menghantar data berbentuk nombor daripada satu micro:bit kepada micro:bit lain menggunakan komunikasi radio.
Dalam contoh gambar:
👉 radio send number 0
Ini bermaksud micro:bit akan menghantar nombor 0 melalui radio.
micro:bit mempunyai modul radio gelombang rendah (2.4GHz) yang boleh menghantar:
nombor
teks
nilai + label
arahan tertentu
Akan tetapi, micro:bit hanya berkomunikasi jika berada dalam group yang sama.
Contoh:
radio set group 1
Nombor ini boleh mewakili apa sahaja:
arahan kawalan
nilai sensor
skor
status butang
pergerakan robot
kod mesej (contoh: 1 = on, 2 = off)
Micro:bit penerima akan membaca nombor tersebut menggunakan:
on radio received number
Blok ini hanya menghantar nombor, contohnya:
1
50
999
suhu
bilangan langkah
nilai analog dari pin
Anda juga boleh hantar pemboleh ubah, bukan hanya nombor tetap.
Contoh:
radio send number temperature
radio set group 7
radio send number 1 // 1 = maju
on radio received number
if receivedNumber == 1 then motor forward
if input.soundLevel() > 150 then
radio send number 9 // 9 = alarm!
on radio received number
if receivedNumber == 9 then show icon alert
Player 1 hantar skor kepada Player 2:
radio send number score
Player 2 papar:
on radio received number
basic.showNumber(receivedNumber)
micro:bit A (sensor):
radio send number input.temperature()
micro:bit B (penerima):
show number receivedNumber
👉 radio send number = Hantar nombor melalui radio kepada micro:bit lain
👉 Digunakan dalam komunikasi, permainan, kawalan robot, sensor wireless
👉 Perlu set group yang sama untuk berfungsi
Blok ini digunakan untuk menghantar data radio dengan format BERPASANGAN, iaitu:
Contoh pada gambar:
👉 radio send value "name" = 0
Ini bermaksud micro:bit akan menghantar mesej radio berbentuk:
name : 0
Apabila menghantar banyak nilai, penerima perlu tahu “nilai apa” yang diterima.
Contoh mesej:
"speed" = 100
"left" = 1
"temperature" = 28
Micro:bit penerima boleh menyusun tindakan berdasarkan label tersebut.
Penerima akan menggunakan blok:
on radio received value
Di dalamnya, terdapat dua pembolehubah automatik:
receivedString → label yang dihantar (contoh: "speed")
receivedNumber → nilai yang dihantar (contoh: 100)
Contoh penggunaan:
on radio received value
if receivedString == "speed" then
motor.setSpeed(receivedNumber)
radio send value "forward" = 1
radio send value "speed" = 80
on radio received value
if receivedString == "forward" and receivedNumber == 1 then
move forward
if receivedString == "speed" then
set motor speed to receivedNumber
radio send value "temp" = input.temperature()
on radio received value
if receivedString == "temp" then
show number receivedNumber
radio send value "score" = score
radio send value "life" = life
radio send value "power" = 3
Anda boleh hantar:
radio send value "light" = input.lightLevel()
radio send value "sound" = input.soundLevel()
radio send value "shake" = 1
👉 radio send value menghantar nilai yang ada label (name)
👉 Memudahkan penerima kenal pasti jenis data
👉 Sangat berguna untuk robot kawalan jauh, sensor wireless, game multiplayer, dan IoT
👉 Digunakan dengan on radio received value
Blok ini digunakan untuk menghantar mesej berbentuk teks (string) daripada satu micro:bit kepada micro:bit lain melalui komunikasi radio.
Contoh pada gambar:
👉 radio send string ""
(ruang kosong — pelajar boleh isi teks sendiri)
Dalam pengaturcaraan, string bermaksud teks seperti:
perkataan
ayat
arahan
simbol
kombinasi huruf + nombor
Contoh string yang boleh dihantar:
"HELLO"
"GO"
"STOP"
"LEFT"
"FIRE"
"MASUK"
"ALERT!"
Contoh mudah:
Micro:bit A:
radio send string "HELLO"
Micro:bit B:
on radio received string
show string receivedString
Contoh:
radio send number 1 → maksudnya tak jelas
radio send string "FORWARD" → maksud terus difahami
remote robot
walkie-talkie
sistem amaran
permainan multiplayer
mesej rahsia (“secret messaging”)
Penerima menggunakan blok:
on radio received string
Pembolehubah automatik:
receivedString → teks yang diterima
Contoh paparkan mesej:
basic.showString(receivedString)
radio send string "HI!"
on radio received string
basic.showString(receivedString)
radio send string "MAJU"
on radio received string
if receivedString == "MAJU" then
motor forward
radio send string "BUNYI KUAT!"
on radio received string
basic.showIcon(IconNames.Skull)
radio.sendString("SHOOT")
radio.sendString("HIT")
radio.sendString("MISS")
👉 radio send string = hantar teks melalui radio antara micro:bit
👉 Lebih mudah dibaca & difahami berbanding nombor
👉 Digunakan dalam chat, robot, alarm, multiplayer game
👉 Perlu padankan dengan on radio received string
Blok ini adalah blok acara (event block) yang akan aktif apabila micro:bit menerima nombor melalui radio daripada micro:bit lain.
Ia digunakan apabila satu micro:bit menghantar nombor menggunakan:
radio send number 5
atau
radio.sendNumber(x)
Apabila micro:bit menerima nombor, blok ini akan:
Mengambil nombor tersebut
Menyimpannya dalam pembolehubah automatik
→ receivedNumber
Menjalankan arahan yang berada di dalam blok
receivedNumber ialah pembolehubah khas yang:
dicipta automatik oleh MakeCode
memegang nilai nombor yang dihantar dari micro:bit lain
berubah-ubah mengikut nombor yang diterima
Contoh:
Jika micro:bit A hantar:
radio send number 9
Micro:bit B akan terima:
receivedNumber = 9
Nombor mewakili arahan:
1 = maju
2 = kiri
3 = kanan
4 = berhenti
main tebak nombor
score counter
balingan dadu
Contoh:
sensor hantar nombor suhu
micro:bit penerima paparkan suhu
hantar data LDR, bunyi, accelerometer
hantar signal 0 atau 1
aktifkan alarm jauh
wireless door alert
Micro:bit A menghantar nombor melalui radio
Micro:bit B menerima nombor tersebut
Blok on radio received aktif automatik
Nombor disimpan dalam receivedNumber
Arahan dalam blok dijalankan
on radio received receivedNumber
show number receivedNumber
on radio received receivedNumber
if receivedNumber == 1 then
motor forward
if receivedNumber == 2 then
motor left
if receivedNumber == 3 then
motor right
if receivedNumber == 4 then
motor stop
Sender:
radio send number input.temperature()
Receiver:
on radio received receivedNumber
show number receivedNumber
👉 Blok ini menunggu nombor dihantar melalui radio
👉 Bila nombor diterima, ia disimpan dalam receivedNumber
👉 Blok kemudian jalankan arahan berdasarkan nombor itu
👉 Penting dalam remote, sensor, game, sistem wireless
Blok ini adalah blok acara (event block) yang akan diaktifkan secara automatik apabila micro:bit menerima string (teks) melalui radio daripada micro:bit lain.
Ia digunakan apabila micro:bit lain menghantar string menggunakan:
radio send string "HELLO"
atau
radio.sendString("GO")
Apabila micro:bit menerima mesej berbentuk teks, blok ini akan:
Mengesan mesej tersebut
Menyimpannya dalam pembolehubah automatik → receivedString
Menjalankan arahan di dalam blok berdasarkan teks yang diterima
receivedString ialah pembolehubah khas yang dicipta secara automatik oleh MakeCode. Ia:
Menyimpan mesej string yang diterima
Sentiasa dikemaskini apabila mesej baharu diterima
Boleh digunakan dalam keadaan IF, paparan, atau untuk kawalan motor, LED, bunyi dan sebagainya
Contoh:
Jika micro:bit A hantar:
radio send string "FIRE"
Micro:bit B akan menerima:
receivedString = "FIRE"
✔ Sistem kawalan jauh (remote control) menggunakan teks
Contoh:
"ON" = hidupkan lampu
"OFF" = matikan lampu
"LEFT" = robot belok kiri
"STOP" = berhenti
✔ Chat ringkas antara dua micro:bit
Hantar mesej "HELLO"
Hantar nama
Mesej status
✔ Mengawal animasi LED
"LOVE" → paparkan hati
"SAD" → paparkan muka sedih
✔ Sistem IOT micro:bit (tanpa internet)
"HOT" → suhu tinggi
"ALERT" → sensor mengesan pergerakan
✔ Permainan multiplayer
"ROLL" → baling dadu
"POINT" → sistem markah
Micro:bit A hantar STRING
Micro:bit B menerima mesej
Blok on radio received receivedString aktif automatik
receivedString diset dengan mesej baharu
Arahan dalam blok dijalankan
on radio received receivedString
show string receivedString
on radio received receivedString
if receivedString == "FORWARD" then
motor forward
if receivedString == "LEFT" then
motor turn left
if receivedString == "STOP" then
motor stop
on radio received receivedString
if receivedString == "LOVE" then
show icon heart
if receivedString == "SAD" then
show icon sad
Sender:
radio send string "ALERT"
Receiver:
on radio received receivedString
if receivedString == "ALERT" then
show icon angry
play sound siren
👉 Blok ini aktif bila micro:bit menerima mesej teks
👉 Mesej itu disimpan dalam receivedString
👉 Kita boleh guna mesej itu untuk arah robot, paparkan mesej, main bunyi, kendali sensor, dan banyak lagi
Blok ini digunakan untuk mendapatkan nilai kekuatan isyarat radio (signal strength) bagi mesej yang baru diterima oleh micro:bit melalui radio.
Ia adalah nilai jenis nombor (number) yang menunjukkan sekuat mana isyarat radio diterima daripada micro:bit pengirim.
Apabila micro:bit menerima mesej melalui radio:
Micro:bit akan mengukur kekuatan isyarat radio tersebut
Blok received packet signal strength memberikan nilai kekuatan itu dalam unit dBm (decibel-milliwatts)
Nilai yang dikembalikan adalah nombor negatif, contohnya:
Nilai (dBm)
Maksud
-40 dBm
Sangat kuat (micro:bit dekat)
-60 dBm
Kuat (jarak sederhana)
-80 dBm
Lemah (jauh / halangan)
-90 dBm
Sangat lemah (hampir hilang)
👉 Semakin besar nombor negatif (contoh –40), semakin kuat isyarat.
👉 Semakin kecil atau lebih negatif (contoh –90), semakin lemah isyarat.
Micro:bit boleh anggar jarak antara dua micro:bit berdasarkan kekuatan isyarat.
Jika micro:bit hilang dalam bilik — boleh buat sistem pengesan.
Dua micro:bit di sudut berbeza mengukur kekuatan isyarat micro:bit pelajar.
Robot bergerak ke arah isyarat paling kuat (robot tracker).
Amaran jika micro:bit tertentu terlalu jauh atau keluar kawasan.
Micro:bit menerima mesej radio
Pada saat itu, micro:bit juga merekod:
receivedNumber atau receivedString
kekuatan isyarat radio
Blok ini dipanggil untuk mendapatkan nilai kekuatan isyarat
Kita boleh gunakan nilai itu untuk kawalan atau paparan
on radio received receivedString
show number received packet signal strength
on radio received receivedNumber
if received packet signal strength < -85 then
show icon sad
else
show icon happy
on radio received receivedString
let rssi = received packet signal strength
if rssi > -60 then
show string "NEAR"
else if rssi > -80 then
show string "MEDIUM"
else
show string "FAR"
Halangan (dinding, badan manusia)
Sudut posisi micro:bit
Interference (WiFi, Bluetooth)
Jarak
Arah antena
Jika tiada mesej diterima → nilai tidak berubah.
👉 Blok ini memberitahu sekuat mana isyarat radio yang diterima
👉 Nilainya negatif, contoh: –40 (kuat), –80 (lemah)
👉 Sesuai untuk projek radar, tracking, kawalan robot, sistem keselamatan
Blok ini digunakan untuk mengawal kekuatan isyarat radio yang dihantar oleh micro:bit.
Nilai yang boleh dipilih ialah 0 hingga 7, di mana:
0 = paling lemah
7 = paling kuat (default)
Semakin kuat kuasa penghantaran, semakin jauh jarak radio boleh pergi dan semakin mudah micro:bit lain menerima mesej tersebut.
Blok ini menetapkan nilai kuasa transmisi (Transmit Power) iaitu kekuatan isyarat radio semasa menghantar mesej.
Kuasa lebih rendah = penggunaan tenaga lebih rendah
Kuasa lebih tinggi = penggunaan tenaga lebih banyak
Jika banyak micro:bit digunakan di kawasan yang sama (contoh kelas besar atau pertandingan), kuasa rendah membantu mengelakkan “pertindihan isyarat”.
Supaya mesej dapat dihantar lebih jauh → set ke 7
Gunakan kuasa tinggi (5–7) supaya robot tak hilang isyarat.
Supaya jarak tidak terlalu jauh → set kuasa rendah (0–3)
Jika mahu ketepatan jarak → kuasa mesti dikekalkan tetap.
Blok ini biasanya diletakkan dalam:
radio set group 1
radio set transmit power 7
Ia hanya perlu dipanggil sekali dalam on start kerana micro:bit akan terus menggunakan nilai yang sama sehingga ditukar.
radio set group 10
radio set transmit power 7
Micro:bit hantar isyarat paling kuat – sesuai untuk jarak jauh.
radio set transmit power 2
Kuasa rendah sesuai untuk komunikasi dekat (atas meja, dalam kelas).
radio set transmit power 1
on radio received receivedNumber
if received packet signal strength < -85 then
show icon NO
else
show icon YES
Isyarat lemah → objek terlalu jauh.
👉 Blok radio set transmit power menentukan berapa kuat radio micro:bit memancarkan isyarat
👉 Nilai 0–7, 7 paling kuat, 0 paling lemah
👉 Kesan utama:
Jarak isyarat
Penggunaan bateri
Gangguan radio
Ketepatan projek jarak (RSSI)
Blok ini digunakan untuk mengawal sama ada micro:bit akan menghantar nombor siri (serial number) setiap kali ia menghantar mesej radio.
Setiap micro:bit mempunyai nombor siri unik (macam IC, atau kad pengenalan).
Contoh serial number micro:bit:
363546589
421002714
589774103
Nombor ini tidak sama untuk setiap micro:bit di dunia.
Jika di-set kepada TRUE, micro:bit akan menghantar nombor siri dirinya sendiri bersama mesej radio yang dihantar.
Micro:bit penerima boleh membaca:
mesej
nombor
signal strength
pengirimnya (serial number) → inilah fungsi blok ini!
Jika terdapat banyak micro:bit dalam kumpulan radio yang sama, kita boleh tahu mesej datang dari micro:bit mana.
Contoh mesej radio jika FALSE:
value = 10
(signal strength = -70)
Jika TRUE, mesej akan mengandungi maklumat tambahan:
value = 10
serial = 421002714
(signal strength = -70)
Maknanya micro:bit penerima boleh tahu siapa hantar mesej itu.
Setiap murid ada satu micro:bit → tekan butang A → hantar nama/angka.
Guru boleh kenal micro:bit siapa melalui "serial number".
Robot akan menghantar serial numbernya → pengawal boleh identifikasi robot A, B, C.
Game seperti “Tag”, “Reaction Race”, “Radio Battle”
Serial number digunakan untuk:
menentukan giliran
kenal pemenang
kenal siapa hantar mesej
Jika pelajar cuba guna micro:bit lain, sistem boleh kesan perbezaan serial number.
radio set group 5
radio set transmit serial number true
radio send number 1
on radio received receivedNumber
show number received packet serial number
👉 Blok ini mengawal sama ada micro:bit menghantar identitinya (serial number) atau tidak
👉 TRUE = hantar serial number (boleh kenal siapa hantar)
👉 FALSE = tidak hantar (mesej ringkas)
👉 Sangat berguna untuk projek dengan ramai micro:bit, multiplayer, robot tracking, sistem kehadiran.
Blok radio set frequency band digunakan untuk menukar jalur frekuensi radio yang digunakan oleh micro:bit semasa berkomunikasi menggunakan Radio.
Secara mudah:
👉 Ia menentukan “laluan radio” yang micro:bit gunakan supaya mesej tidak bercampur dengan kumpulan lain.
Micro:bit menggunakan frekuensi sekitar 2.4 GHz, iaitu frekuensi sama seperti:
WiFi
Bluetooth
Walkie-talkie digital
Untuk mengelakkan gangguan (interference), frekuensi besar ini dibahagikan kepada beberapa band (jalur).
Dalam MakeCode, pengguna boleh memilih band:
0, 1, 2, 3, 4, 5, 6, 7
Setiap band ialah 'laluan frekuensi berbeza'.
Jika ada ramai pelajar guna radio dalam satu bilik darjah, signal boleh bercampur.
Dengan menukar frequency band, setiap kumpulan boleh guna laluan radio yang berbeza.
Contohnya:
Kumpulan A guna band 0
Kumpulan B guna band 2
Kumpulan C guna band 5
Mereka tidak akan saling menerima mesej walaupun group radio sama.
Band lain = lebih selamat daripada micro:bit lain yang tersilap group.
20 robot → 10 kumpulan → semua guna radio.
Jika hanya guna group sahaja:
Ada risiko signal sampai ke robot kumpulan lain
Ada gangguan radio bila ramai menghantar serentak
Jika ditambah frequency band yang berbeza:
Robot hanya dengar rakan kumpulan dalam band sama
Gangguan radio berkurang
Prestasi robot lebih stabil
radio set frequency band 3
radio set group 10
radio send number 1
Micro:bit lain mesti guna:
Band 3
Group 10
barulah boleh berkomunikasi.
👉 radio set frequency band = menukar laluan radio.
👉 Semua micro:bit mesti guna nilai band yang sama untuk bercakap.
👉 Kalau band berbeza → mereka tak boleh berhubung langsung.
👉 Digunakan untuk kurangkan gangguan dan bagi projek besar lebih stabil.
from source: MICROBIT_ID_BUTTON_A
with value: MICROBIT_EVT_ANY
Blok radio raise event digunakan untuk menghantar satu "event" (peristiwa) melalui radio kepada micro:bit lain.
👉 Maksudnya, micro:bit boleh mencipta isyarat khas dan menyiarkannya kepada semua micro:bit lain yang mendengar radio group yang sama.
Event = satu pemberitahuan peristiwa, seperti:
Button ditekan
Sensor berubah nilai
Logo disentuh
Gerakan tertentu
Atau event buatan sendiri
Dalam kes ini, kita memberitahu micro:bit lain bahawa butang A mengalami satu peristiwa.
Ini bermaksud:
👉 Sumber event yang dihantar ialah Button A micro:bit.
Ini melambangkan event yang berkaitan dengan BUTANG A seperti:
ditekan
dilepaskan
ditekan lama
apa saja event yang berlaku pada Button A
Ini bermaksud:
👉 Nilai event adalah ANY (apa sahaja jenis event)
Maknanya:
Ditekan = diterima
Dilepaskan = diterima
Long pressed = diterima
Double pressed = diterima
Semua jenis event untuk Button A akan dihantar.
Blok ini memberitahu micro:bit lain melalui radio bahawa:
“Button A pada micro:bit saya baru sahaja mengalami apa-apa event.”
Di micro:bit lain, kita boleh gunakan blok:
Untuk mengesan event yang dihantar.
Contoh di micro:bit penerima:
on radio event from MICROBIT_ID_BUTTON_A with MICROBIT_EVT_CLICK
show icon Heart
Ini bermaksud:
👉 Bila micro:bit lain tekan butang A, micro:bit penerima akan tunjuk ikon 💓
Event radio digunakan bila cikgu mahu:
Tidak hanya sekadar hantar nombor/string.
Event membolehkan micro:bit menghantar peristiwa khusus.
Contoh:
Tekan butang A → robot bergerak
Long press → robot berhenti
Contoh:
1 micro:bit sebagai "remote"
Banyak micro:bit lain sebagai "receiver"
Seperti:
Button A = event #1
Touch logo = event #2
Shake = event #3
Sesuai untuk game multiplayer atau robot battle.
Micro:bit 1 (remote)
on button A pressed
radio raise event MICROBIT_ID_BUTTON_A with MICROBIT_EVT_CLICK
Micro:bit 2 (robot)
on radio event from MICROBIT_ID_BUTTON_A with MICROBIT_EVT_CLICK
move forward
Blok ini tidak menghantar nombor atau string, tetapi event.
Micro:bit penerima mesti guna blok event radio juga.
“ANY Event” bermakna semua jenis event butang A dihantar.
Icon Loops ini adalah kategori blok atur ulangan.
Fungsinya ialah untuk mengulang arahan yang sama berkali-kali secara automatik, tanpa perlu tulis arahan itu banyak kali.
Loops sangat penting untuk:
animasi LED
bacaan sensor berterusan
permainan
robotik
pemasa & counter
proses automatik
Berikut adalah blok yang biasa terdapat dalam Loops:
forever:
← semua arahan di dalam ini akan ulang tanpa henti
Micro:bit akan menjalankan arahan dalam blok ini berulang-ulang.
Tiada had, tiada berhenti.
Contoh guna:
papar suhu setiap 1 saat
animasi LED
bacaan sensor berterusan
robot bergerak sambil memeriksa halangan
repeat 5 times:
← arahan di dalam akan ulang sebanyak bilangan yang ditetapkan
Ulang sebanyak yang ditentukan, kemudian berhenti.
Contoh:
berkelip 10 kali
kirakan countdown 5 langkah
ulang melodi 3 kali
while (syarat benar):
← ulang arahan sehingga syarat menjadi salah
Ulang hanya selagi keadaan tertentu betul.
Contoh:
selagi butang A ditekan → nyalakan LED
selagi jarak sensor > 10 → robot terus berjalan
selagi suhu < 30°C → hidupkan kipas
for index from 0 to 4:
← ulang sambil kira nombor
Ulang sambil menggunakan pembolehubah kiraan (index).
Contoh:
gerakkan cahaya dari kiri → kanan
hitung 1 hingga 10
plot LED mengikut pola
Walaupun bukan loop, ia sering berada dalam kategori Loops.
pause 1000 ms (1 saat)
Fungsi:
berhenti sekejap sebelum sambung arahan
penting untuk:
animasi LED
tempoh menunggu
mengurangkan kelajuan loop
memberi masa untuk sensor stabil
Menghentikan ulangan walaupun loop belum selesai
Berguna untuk hentikan permainan bila syarat tertentu tercapai
“Kategori Loops digunakan untuk mengulang arahan secara automatik.
Ia membantu jimat masa, kemas atur cara, dan menjalankan kerja berulang seperti animasi, bacaan sensor & kawal robot.”
LED berkelip-kelip
Animasi hati berdenyut
Baca nilai suhu setiap 0.5 saat
Robot bergerak selagi tiada halangan
Counter nombor naik 1 hingga 10
Jam digital (loop selamanya)
Blok ini adalah gelung ulangan (loop) yang digunakan untuk mengulangi arahan dalam blok “do” sebanyak bilangan yang ditetapkan.
Blok repeat 4 times do akan:
👉 Menjalankan semua arahan di dalam bahagian “do”
👉 sebanyak 4 kali
Jika cikgu tukar nombor 4 kepada nombor lain, micro:bit akan mengulang mengikut nilai tersebut.
Contoh:
repeat 4 times
show icon Heart
Micro:bit akan:
❤️ Tunjuk ikon sekali
❤️ Tunjuk ikon kali kedua
❤️ Tunjuk ikon kali ketiga
❤️ Tunjuk ikon kali keempat
➡️ Total: 4 kali
➡️ Lepas habis ulangan, program terus ke blok seterusnya.
Penggunaan blok ini sangat berguna apabila cikgu mahu:
– Contoh: lampu berkelip 10 kali
– Contoh: beep 3 kali
– Contoh: servo ke kiri-kanan 5 kali
– Contoh: ambil bacaan sebanyak 20 kali
– Contoh: melangkah 4 kali ke depan
Micro:bit membaca begini:
1️⃣ Masuk loop → Ulangan pertama
2️⃣ Jalan arahan dalam "do"
3️⃣ Balik semula ke atas
4️⃣ Ulang ulangan sehingga nombor mencapai bilangan yang ditetapkan
5️⃣ Keluar loop bila selesai semua
repeat 5 times
led.toggle(2, 2)
pause 200
repeat 3 times
music.playTone(Note.C, 200)
music.rest(100)
repeat 4 times
motorForward()
pause(500)
Blok
Fungsi
repeat X times
Ulang jumlah tertentu sahaja
forever
Ulang tanpa henti
while
Ulang selagi syarat benar
for index from A to B
Ulang dengan pengiraan dan pembolehubah
Blok repeat adalah yang paling mudah dan sesuai untuk murid Tahun 6.
Blok repeat _ times do mengarahkan micro:bit untuk mengulangi arahan dalam bahagian “do” sebanyak bilangan yang ditetapkan.
Ia sangat sesuai digunakan untuk mengawal ulangan animasi, bunyi, pergerakan atau apa sahaja yang perlu dilakukan berkali-kali.
Blok ini adalah gelung ulangan bersyarat (conditional loop) yang akan mengulang arahan di dalam “do” selagi syarat adalah BENAR (true).
Jika syarat menjadi false, ulangan akan berhenti serta-merta.
Blok while (syarat) do digunakan apabila kita mahu:
✔ mengulangi sesuatu SELAGI keadaan tertentu berlaku
✔ menghentikan ulangan apabila syarat tidak lagi benar
✔ membuat kawalan yang bergantung kepada sensor, input, nilai pembolehubah atau logik tertentu
Ia berfungsi seperti:
“SELAGI syarat BENAR, teruskan melakukan arahan di bawah.”
Micro:bit periksa syarat di bahagian while ( ... )
Jika syarat true, micro:bit jalankan semua arahan di dalam blok do
Lepas habis arahan, ia kembali memeriksa syarat semula
Ulangan hanya berhenti apabila syarat false
Dalam gambar yang cikgu beri:
Ini bermaksud syarat sentiasa false, jadi:
❌ Ulangan tidak akan berjalan langsung
❌ Micro:bit akan terus melangkau blok ini
✔ Ini hanya contoh awal—murid perlu tukar syarat kepada sesuatu yang logik
while button A is pressed
show icon Heart
Micro:bit akan menunjukkan icon ❤️ selagi murid tekan butang A.
while temperature < 30
show leds
Program akan berulang sehingga suhu mencecah 30°C.
while light level < 100
led.plot(2, 2)
LED di tengah akan menyala selagi keadaan gelap.
while distance > 10
motor.forward()
Robot akan bergerak selagi belum hampir ke halangan.
Blok while boleh menyebabkan infinite loop (gelung tak berakhir) jika:
✔ syarat sentiasa benar
✔ tiada perubahan dalam loop untuk mematikan syarat
Contoh infinite loop:
while true
show icon Heart
Micro:bit akan berulang tanpa henti, tidak memberi peluang blok lain berjalan.
Blok
Cara Berfungsi
repeat X times
Ulang jumlah tertentu sahaja
forever
Ulang tanpa henti
while
Ulang selagi syarat benar
for index from A to B
Ulang dengan kiraan pembolehubah
Blok while adalah paling fleksibel tetapi perlu digunakan dengan berhati-hati.
Blok while (syarat) do mengulang arahan selagi syarat TRUE. Bila syarat FALSE, ulangan berhenti.
Sangat berguna untuk kawalan sensor, robot bergerak, syarat masa nyata atau logik berterusan.
Blok ini ialah gelung ulangan berbilang langkah (counting loop).
Ia digunakan untuk mengulangi arahan beberapa kali sambil mengira menggunakan pembolehubah index.
Blok ini akan:
Mewujudkan satu pembolehubah sementara bernama index
Tetapkan nilai permulaan index = 0
Jalankan arahan di dalam blok do
Tambah index sebanyak 1 setiap pusingan
Berhenti apabila index melebihi nilai akhir (dalam contoh ini, 4)
Dalam blok:
for index from 0 to 4
Ulangan berlaku sebanyak:
📌 5 kali — iaitu untuk nilai:
index = 0
index = 1
index = 2
index = 3
index = 4
✔ index hanya wujud di dalam loop
✔ index bertambah secara automatik
✔ membolehkan murid mengakses nilai ulangan semasa (contoh: posisi LED, nombor turutan)
✔ lebih teratur berbanding ulangan tanpa kiraan
for index from 0 to 4
plot index 0
LED pada koordinat (0,0) → (4,0) akan menyala satu persatu.
for index from 0 to 4
show number index
Micro:bit memaparkan 0, 1, 2, 3, 4.
for index from 0 to 4
move forward
Robot bergerak ke depan 5 kali.
let jumlah = 0
for index from 0 to 4
jumlah = jumlah + index
Akhirnya jumlah = 10.
Blok
Fungsi
repeat X times
Ulang X kali tanpa pembolehubah kiraan
while
Ulang selagi syarat benar
forever
Ulang tanpa henti
for
Ulang sambil menjejak pembolehubah index
Blok for lebih sesuai untuk:
✔ animasi LED
✔ pergerakan berurutan
✔ pengiraan matematik
✔ pemprosesan berulang yang memerlukan nilai penghitung
Blok for index from 0 to 4 do mengulangi arahan 5 kali sambil menaikkan nilai index setiap pusingan.
Nilai index = 0,1,2,3,4.
Blok ini adalah gelung (loop) khas yang digunakan untuk mengulangi setiap item (elemen) dalam satu senarai (list).
Ia sangat berguna apabila cikgu ada list yang mengandungi banyak nilai, dan kita mahu memproses semua nilai tersebut satu per satu.
Blok ini:
Mengambil satu elemen daripada list pada setiap pusingan.
Menyimpannya dalam pembolehubah sementara (contoh: value).
Jalankan arahan dalam bahagian do menggunakan nilai tersebut.
Bergerak ke elemen seterusnya.
Berhenti apabila semua elemen dalam list telah diproses.
Blok
Kegunaan
for index from 0 to X
Sesuai untuk ulangan berasaskan nombor/pengiraan
for element of list
Sesuai untuk mengambil nilai terus daripada senarai
Dengan kata lain:
➡ for index = ulang berdasarkan kiraan
➡ for element = ulang berdasarkan nilai dalam senarai
for element value of list
show number value
Micro:bit akan paparkan kandungan list satu demi satu.
let jumlah = 0
for element value of list
jumlah = jumlah + value
Jika list = [3, 4, 5] → jumlah = 12
Jika cikgu ada list koordinat X:
xList = [0, 2, 4]
for element value of xList
plot value 2
LED pada (0,2), (2,2), (4,2) akan menyala.
arah = ["left", "forward", "right"]
for element value of arah
if value = "left"
turn left
if value = "forward"
move straight
if value = "right"
turn right
Robot ikut "arahan dalam list".
✔ sangat berguna untuk data, senarai bacaan sensor, koordinat LED, item tekstual, nilai nombor
✔ lebih cepat daripada menulis if-else banyak kali
✔ mudah untuk murid memahami struktur data
Blok for element value of list akan ulang arahan bagi setiap elemen dalam senarai, satu demi satu. Nilai elemen disimpan dalam pembolehubah sementara seperti value.
Blok ini digunakan untuk menjalankan arahan secara berulang-ulang pada sela masa tertentu.
“500 ms” bermaksud 500 milisaat = 0.5 saat.
Dengan kata lain:
Apa sahaja arahan di dalam blok ini akan dilaksanakan setiap 0.5 saat secara automatik.
✔ Menjalankan arahan berkala (periodic)
✔ Sesuai untuk animasi, bacaan sensor, kiraan masa, flashing, dan pemantauan berulang
✔ Berjalan secara parallel (selari) dengan blok lain
✔ Tidak menghentikan program utama seperti dalam loop biasa
Jika cikgu set:
every 500 ms
Langkah kerjanya:
Program menunggu 0.5 saat pertama
Jalankan arahan dalam blok “do”
Tunggu lagi 0.5 saat
Jalankan arahan sekali lagi
Ulang selagi micro:bit hidup
Blok ini tidak berhenti, kecuali micro:bit dimatikan atau arahan diganti.
Blok
Keterangan
forever
Ulang tanpa henti, tetapi segera secepat mungkin
every ms
Ulang tanpa henti dengan sela masa tetap (delay tetap)
Contoh:
forever = ulang 1000 kali sesaat
every 500 ms = ulang hanya 2 kali sesaat
every 1000 ms
toggle x 2 y 2
LED di tengah menyala–padam setiap 1 saat.
every 2000 ms
show number temperature
every 500 ms
radio send number 1
every 200 ms
change x by 1
every 300 ms
if sound level > 150
show icon Angry
✔ Menjalankan arahan automatik tanpa melambatkan program lain
✔ Sangat sesuai untuk projek IoT, data logger, robot autonomi, dan monitoring
✔ Boleh digunakan serentak dengan beberapa blok every lain (multi-schedule tasks)
Blok every 500 ms menjalankan arahan secara berulang setiap 0.5 saat tanpa mengganggu kod lain. Ia seperti jam timer yang berbunyi secara berkala.
Blok break digunakan dalam MakeCode untuk memberhentikan loop (gelung ulangan) serta-merta sebelum loop itu selesai.
Ia hanya berfungsi di dalam blok ulangan seperti:
repeat X times
while
for index …
for element of list
Tidak boleh digunakan di luar loop.
✔ Menghentikan loop serta-merta
✔ Melompat keluar dari loop, terus sambung kod selepas loop
✔ Mengawal aliran program supaya ulangan tidak perlu diteruskan
✔ Menjimatkan masa dan memori apabila syarat tertentu dipenuhi
Contoh loop 10 kali:
repeat 10 times
if something is true
break
(arahan lain)
Apabila kondisi if dipenuhi:
Blok break dijalankan
Loop dihentikan serta-merta
Kod keluar daripada cycle ulangan
Program terus menjalankan arahan selepas loop
Ulangan tidak diteruskan, walaupun bilangan sepatutnya masih berbaki.
for element value of list
if value == 7
show icon Heart
break
Loop akan berhenti bila jumpa angka 7.
for index from 0 to 4
if logo is pressed
break
plot index 2
pause 200
LED bergerak kiri–kanan tetapi berhenti jika logo ditekan.
repeat 50 times
if sound level > 150
show icon Angry
break
Tidak terus ulang 50 kali — berhenti terus jika suara terlalu kuat.
while true
move forward
if distance < 10
break
Robot keluar dari loop dan berhenti bergerak.
(Jika cikgu nanti jumpa kod yang ada continue)
Perintah
Fungsi
break
Keluar dari loop sepenuhnya
continue
Langkau satu pusingan, sambung pusingan seterusnya
break ialah perintah untuk memberhentikan loop serta-merta, walaupun loop belum selesai. Ia digunakan untuk menghentikan ulangan apabila sesuatu syarat dipenuhi.
Blok continue digunakan di dalam loop (gelung ulangan) untuk melangkau baki arahan dalam pusingan semasa dan terus pergi ke pusingan seterusnya.
Blok ini hanya boleh digunakan di dalam loop seperti:
repeat X times
while
for index …
for element of list
✔ Mengabaikan semua kod selepas continue dalam pusingan itu
✔ Melompat terus ke pusingan ulangan berikutnya
✔ Tidak keluar dari loop (berbeza dengan break)
✔ Sesuai digunakan apabila kita ingin skip sesuatu keadaan tertentu
Contoh loop:
repeat 5 times
if index = 2
continue
show number index
Bagaimana ia berjalan?
Pusingan 0 → tunjuk nombor 0
Pusingan 1 → tunjuk nombor 1
Pusingan 2 → jumpa continue, jadi nombor tidak ditunjuk. Skip!
Pusingan 3 → tunjuk nombor 3
Pusingan 4 → tunjuk nombor 4
Loop tetap habis 5 kali, tetapi pusingan tertentu dilangkau.
for index from 0 to 4
if index == 2
continue
plot index 2
LED pada kolum 2 tidak akan menyala.
for element value of list
if value < 0
continue
sum = sum + value
Hanya tambah nilai positif.
while true
if distance < 5
continue // skip tindakan lain, tunggu bacaan stabil
move forward
repeat 20 times
if sound level < 50
continue
show icon Loud
Ikon hanya muncul jika bunyi kuat.
continue ialah perintah untuk melangkau baki arahan dalam pusingan semasa dan terus ke pusingan berikutnya. Loop tidak dihentikan.
Kategori Logic digunakan untuk membuat keputusan, perbandingan, dan syarat dalam program.
Dalam dunia pengaturcaraan, Logic ialah “otak” yang menentukan:
👉 Bila sesuatu perlu berlaku
👉 Bila sesuatu perlu berhenti
👉 Apa tindakan seterusnya
👉 Bagaimana program bertindak balas terhadap input
Logic sangat penting dalam:
sensor (jarak, suhu, cahaya)
permainan
robotik
mikrokontroler automasi
interaksi butang, suara, sentuhan
Ini ialah blok syarat yang paling penting.
if (syarat benar):
lakukan A
else:
lakukan B
Contoh situasi:
Jika suhu > 30°C → hidupkan icon panas
Jika butang A ditekan → tunjuk hati
Jika gelap → nyalakan lampu
if only
tindakan berlaku hanya jika syarat benar
if … else
ada dua pilihan tindakan
if … else if … else
banyak pilihan syarat (multi-condition)
Nilai ini hanya ada dua:
TRUE = betul
FALSE = salah
Contoh kegunaan:
sensor disentuh = true
butang A ditekan = true
suhu < 20 = false
receivedNumber == 1 = true
Boolean digunakan dalam blok IF.
Blok seperti:
== (sama dengan)
!= (tidak sama)
> (lebih besar)
< (lebih kecil)
>= (lebih besar atau sama)
<= (lebih kecil atau sama)
Contoh:
suhu > 30
jarak == 0
cahaya < 100
Digunakan untuk sensor dan kawalan robot.
Kedua-dua syarat mesti benar.
Contoh:
suhu > 30 dan cahaya < 20
(dua-dua mesti betul)
Salah satu syarat benar pun cukup.
Contoh:
butang A ditekan atau butang B ditekan
Terbalikkan keadaan.
Contoh:
not (butang A ditekan)
(maksudnya butang A TIDAK ditekan)
Blok siap pakai untuk menghasilkan nilai benar / salah.
Digunakan untuk:
testing
debugging
logik ringkas
“Kategori Logic digunakan untuk buat keputusan dalam program.
Semua sensor, butang dan robot akan bertindak berdasarkan jika… maka…
Logic ialah otak micro:bit yang fikir sama ada sesuatu itu benar atau salah.”
if (cahaya < 50):
nyalakan LED
else:
padamkan LED
if (jarak < 10):
bunyikan siren
if (jarak < 15):
berhenti
else:
maju
Blok if ialah blok kawalan keputusan (decision control).
Ia digunakan untuk menjalankan sesuatu arahan hanya apabila syarat tertentu adalah BENAR (true).
✔ Memeriksa satu syarat / keadaan
✔ Jika syarat itu true, maka kod dalam blok akan dijalankan
✔ Jika syarat itu false, maka kod dalam blok akan diabaikan
✔ Teras asas logik pemprograman – digunakan untuk membuat peraturan, syarat, respons automatik dan kawalan robot
Struktur asas:
if (syarat) then
// buat sesuatu
Maknanya:
Micro:bit menilai syarat
Jika syarat = true, arahan dalam blok akan dijalankan
Jika syarat = false, micro:bit tidak buat apa-apa
Kemudian program sambung ke blok seterusnya
if button A is pressed then
show icon heart
● Micro:bit cek butang A
● Jika benar, paparkan hati
● Jika tidak ditekan, tiada paparan
if temperature ≥ 30 then
turn fan on
if distance < 10 then
stop motors
if light level < 50 then
turn on LED
Blok if hanya menerima Boolean = true / false
Antara jenis syarat:
x > 5
suara > 100
jarak <= 10
button A is pressed
pin P0 is pressed
light level < 30
temperature > 27
compass heading == 90
true
false
NOT, AND, OR
Dalam gambar cikgu, syarat ialah:
if true then
(kod)
Maksudnya:
✔ Syarat ini sentiasa benar
✔ Kod dalam blok akan sentiasa berjalan, setiap kali program sampai ke blok itu
❗ Ini jarang digunakan dalam projek sebenar
✔ Biasanya digunakan untuk debug, test code, atau aktifkan fungsi sementara
“If bermaksud: Kalau syarat ini betul, barulah micro:bit buat arahan di bawahnya.”
Blok ini ialah struktur kawalan keputusan yang membolehkan program memilih dua tindakan yang berbeza bergantung kepada syarat.
Ia digunakan apabila kita mahu micro:bit membandingkan sesuatu, kemudian memilih sama ada melakukan A atau B.
✔ Memeriksa satu syarat
✔ Jika syarat = TRUE (benar) → jalankan arahan dalam bahagian “then”
✔ Jika syarat = FALSE (tidak benar) → jalankan arahan dalam bahagian “else”
✔ Memberi dua pilihan tindakan bergantung kepada keadaan
✔ Digunakan untuk membuat logik “jika tidak…”
Struktur asas:
if (syarat) then
// arahan apabila syarat benar
else
// arahan apabila syarat salah
Micro:bit akan:
Menilai syarat
Jika syarat betul → jalankan bahagian then
Jika syarat salah → jalankan bahagian else
Kemudian teruskan program
Jenis
Fungsi
if sahaja
Hanya jalankan kod bila syarat benar; kalau salah → abaikan
if + else
Ada dua laluan pilihan: satu untuk benar & satu lagi untuk salah
Contoh mudah:
“Kalau hujan → buka payung, kalau tak hujan → simpan payung.”
if button A is pressed then
show icon heart
else
show icon no
if distance < 10 then
stop motor
else
run motor forward
if light level < 50 then
turn on LED
else
turn off LED
if temperature ≥ 30 then
fan on
else
fan off
Blok ini ada simbol ( + ) di bawah.
Fungsi:
✔ Menambah else if
✔ Untuk membuat lebih banyak syarat bertingkat
Contoh:
If suhu > 35 → Kipas laju
Else if suhu > 30 → Kipas sederhana
Else → Kipas perlahan
Struktur:
if (syarat 1) then
else if (syarat 2) then
else
“Blok ini digunakan apabila kita mahu pilih antara dua tindakan. Jika syarat betul, buat yang atas. Kalau tak betul, buat yang bawah.”
Blok ini digunakan untuk membuat perbandingan antara dua nilai. Ia menghasilkan keputusan dalam bentuk:
✔ TRUE (benar)
atau
✔ FALSE (salah)
Ini ialah blok logik yang sangat penting dalam pembinaan syarat seperti if, while, atau repeat until.
Blok ini membandingkan nilai di sebelah kiri dengan nilai di sebelah kanan menggunakan operator seperti:
= (sama dengan)
≠ (tidak sama dengan)
< (kurang daripada)
> (lebih daripada)
≤ (kurang atau sama)
≥ (lebih atau sama)
Jika perbandingan betul, blok akan mengembalikan TRUE.
Jika perbandingan tidak betul, blok menghasilkan FALSE.
Blok ini dimasukkan ke dalam blok seperti:
if … then
if … then else
while
repeat until
Boolean checks
Contoh:
5 = 5 → TRUE
3 = 7 → FALSE
4 < 10 → TRUE
10 > 20 → FALSE
Micro:bit akan mengira, kemudian menentukan sama ada perbandingan itu benar atau salah.
if button A is pressed = true then
show icon ♥
if temperature = 30 then
fan on
if light level < 50 then
turn on LED
if count ≥ 10 then
stop animation
✔ Dalam if statement
✔ Dalam loop while
✔ Dalam repeat until
✔ Dalam logik kawalan robot
✔ Dalam bacaan sensor (ultrasonik, cahaya, suhu, butang, accelerometer)
Blok perbandingan ialah asas kepada pemikiran logik dan kawalan automasi.
Tanpa blok ini, micro:bit:
✘ tidak boleh membuat keputusan
✘ tidak boleh bertindak mengikut syarat
✘ tidak boleh mengawal sensor secara pintar
Inilah blok yang menjadikan projek micro:bit “berfikir”, bukan sekadar melaksanakan arahan linear.
“Blok ini digunakan untuk tanya soalan betul atau salah. Jika dua nilai sama, ia kata TRUE. Jika tak sama, ia kata FALSE.”
Blok ini ialah operator logik perbandingan yang digunakan untuk menentukan sama ada nilai di sebelah kiri adalah lebih kecil daripada nilai di sebelah kanan.
Ia menghasilkan keputusan dalam bentuk:
✔ TRUE (benar)
atau
✔ FALSE (salah)
Blok ini membandingkan nilai kiri dengan nilai kanan:
Jika nilai kiri kurang daripada nilai kanan → hasil TRUE
Jika nilai kiri lebih besar atau sama dengan nilai kanan → hasil FALSE
Blok ini biasa digunakan dalam:
if … then
if … else
repeat until
while
mengawal animasi
logik sensor
if light level < 50 then
turn on LED
👉 LED hidup hanya apabila cahaya kurang daripada 50 (keadaan gelap).
if distance < 10 then
stop motor
👉 Motor berhenti jika objek terlalu dekat.
if x < 4 then
x = x + 1
👉 LED bergerak ke kanan selagi nilai x kurang daripada 4 (had skrin micro:bit: 0–4).
if temperature < 25 then
show icon ❄️
👉 Papar simbol sejuk jika suhu di bawah 25°C.
✔ Logik kondisi sensor
✔ Automasi robot
✔ Animasi LED matriks
✔ Kawalan permainan (sprites / positions)
✔ Keputusan bersyarat
Tanpa blok ini, micro:bit tidak boleh menilai angka dan membuat keputusan bergantung pada perubahan bacaan sensor.
“Blok ini tanya sama ada nombor kiri lebih kecil daripada nombor kanan. Kalau betul, hasilnya TRUE. Kalau salah, hasilnya FALSE.”
(String Comparison Block)
Blok ini ialah operator perbandingan (comparison operator) yang digunakan untuk membandingkan dua teks (string).
Ia digunakan untuk menentukan sama ada kedua-dua teks adalah sama (identikal).
Blok ini akan menghasilkan nilai:
✔ TRUE (benar) — jika kedua-dua teks sama 100%
✔ FALSE (salah) — jika kedua-dua teks tidak sama
“String” ialah data dalam bentuk teks seperti:
perkataan
huruf
simbol
gabungan nombor + huruf
mesej radio
Blok ini memeriksa sama ada teks kiri = teks kanan.
Digunakan untuk menentukan mesej apakah yang diterima.
if receivedString = "start" then
run motor
👉 Motor hanya bergerak apabila micro:bit menerima mesej "start".
Contoh: jika murid menaip teks dalam input.
if text = "A" then
show icon ♥
Cth. sistem password guna input micro:bit:
if password = "1234" then
show icon ☺
Contoh: pilih "PLAY", "EXIT", "HELP".
if option = "PLAY" then
start game
Micro:bit A hantar:
radio send string "LED_ON"
Micro:bit B terima:
if receivedString = "LED_ON" then
turn on LED
Jika pelajar tekan A → hantar "YES"
Jika tekan B → hantar "NO"
Di pihak penerima:
if receivedString = "YES" then
yesCount = yesCount + 1
if mode = "rain" then
play rain animation
else if mode = "heart" then
show heart animation
Blok ini tanya: adakah teks kiri sama dengan teks kanan? Kalau sama → TRUE. Kalau tak sama → FALSE.
Ia digunakan untuk buat keputusan berdasarkan teks, terutamanya mesej radio.
Blok ini ialah operator logik yang digunakan untuk menggabungkan dua syarat (conditions).
Ia berada di bawah kategori Logic → Boolean.
Blok “and” digunakan untuk memeriksa:
Adakah kedua-dua syarat adalah BENAR (TRUE)?
Jika kedua-duanya benar, hasilnya = TRUE
Jika salah satu atau kedua-duanya salah, hasilnya = FALSE
Kerana kadang-kadang kita mahu dua syarat wajib dipenuhi serentak.
Contoh:
Butang A ditekan dan suhu > 30°C
Pergerakan dikesan dan cahaya gelap
Radio menerima mesej "GO" dan jarak < 10cm
Gesture "shake" berlaku dan mikrofon bunyi kuat
if button A is pressed AND temperature > 30 then
turn on LED
Kalau salah satu syarat tak benar → LED tak hidup.
if light level < 50 AND gesture shake then
show heart
if receivedString = "GO" AND sound level > 150 then
spin motor
Micro:bit hanya bunyikan alarm jika:
Ada pergerakan (motion detected)
Suara kuat dalam bilik
if motion detected AND sound level > 150 then
play alarm sound
Kalau pergerakan tanpa bunyi → tak aktif
Kalau bunyi tanpa pergerakan → tak aktif
Kalau dua-dua berlaku → sistem aktif
“AND” bermaksud kedua-dua syarat mesti betul baru tindakan berlaku. Jika satu syarat salah → tak aktif.
Blok ini ialah operator logik yang digunakan untuk menggabungkan dua syarat, tetapi cara kerjanya berbeza daripada “and”.
Blok “OR” digunakan untuk memeriksa:
Adakah sekurang-kurangnya SATU syarat adalah BENAR (TRUE)?
Jika sekurang-kurangnya satu syarat benar → hasil = TRUE
Jika kedua-duanya salah → hasil = FALSE
Apabila kita mahu tindakan berlaku walaupun hanya satu syarat dipenuhi.
Contoh:
Tekan Button A ATAU Button B
Cahaya terlalu terang ATAU terlalu gelap
Sensor bunyi kuat ATAU gesture shake
Suhu lebih 30°C ATAU kurang 10°C
if button A is pressed OR button B is pressed then
turn on LED
Maknanya:
Tekan A → hidup
Tekan B → hidup
Tekan kedua-duanya → hidup
Tidak tekan apa-apa → tak hidup
if light level < 50 OR sound level > 150 then
play alarm
Satu syarat cukup untuk aktifkan alarm.
if gesture shake OR gesture free fall then
radio send string "HELP"
Alarm berbunyi jika:
Pintu bilik dibuka ATAU
Bunyi kuat dikesan
if doorOpen = true OR sound level > 120 then
play tone Middle C
Kenapa guna OR?
Sebab kita mahu penggera berbunyi jika mana-mana keadaan berlaku.
“OR” bermaksud salah satu syarat cukup untuk jadi BENAR.
Jika kedua-dua syarat SALAH baru ia jadi FALSE.
Blok NOT ialah operator logik yang digunakan untuk membalikkan (invert) nilai sesuatu syarat.
Maksudnya:
Jika syarat TRUE → NOT menjadikannya FALSE
Jika syarat FALSE → NOT menjadikannya TRUE
Ia digunakan untuk situasi di mana kita ingin memeriksa apa yang TIDAK berlaku.
Fungsi utama:
Blok ini mengambil satu syarat dan menukarnya kepada nilai yang bertentangan.
Digunakan apabila kita mahu menguji perkara yang bertentangan atau yang tidak berlaku.
Contoh keadaan:
Button tidak ditekan
Mikrofon tidak bunyi
Sensor cahaya tidak gelap
Objek tidak dikesan
Pembolehubah bukan pada nilai tertentu
if NOT button A is pressed then
show icon NO
Maksud:
Jika tidak tekan A → tunjuk ❌
Jika tekan A → jangan tunjuk ❌
if NOT (light level < 50) then
plot all LEDs
Makna logik:
Jika bilik tidak gelap → LED hidup
Jika bilik gelap → LED tidak hidup
if NOT (gesture shake) then
radio send string "SAFE"
Maksud:
Jika micro:bit tidak digoncang, hantar mesej “SAFE”.
while NOT (x = 10) do
change x by 1
NOT = lawan bagi syarat.
Jika syarat benar, NOT jadikan salah.
Jika syarat salah, NOT jadikan benar.
Blok
Fungsi
AND
kedua-dua syarat perlu benar
OR
salah satu syarat perlu benar
NOT
membalikkan syarat
Blok NOT sangat berguna untuk syarat penolakan seperti:
"Jika BUKAN..."
"Jika TIDAK..."
"Jika bukan sama dengan..."
Blok true ialah nilai Boolean yang sentiasa bernilai BENAR (TRUE).
Dalam pengaturcaraan, Boolean (logik) hanya mempunyai dua nilai:
TRUE = benar / ya / betul
FALSE = salah / tidak / bohong
Blok true digunakan dalam bahagian syarat seperti:
IF
WHILE
LOGIC test
COMPARISON operator
OR / AND logik
Ia memberikan nilai benar tanpa sebarang syarat.
Jika digunakan dalam IF, syarat itu akan sentiasa berlaku.
Contoh:
if true then
show icon Heart
Ini bermaksud ikon sentiasa dipaparkan kerana syarat itu sentiasa benar.
Contoh:
while true do
show leds
Ini mencipta gelung infiniti (infinite loop) kerana syarat sentiasa benar.
Contoh:
if true AND (x > 5) then
...
Dalam kes ini, syarat sebenar yang diuji hanyalah (x > 5) kerana true AND apa-apa = ikut syarat kedua.
Kadang-kadang digunakan bagi:
Uji sama ada blok lain berfungsi
Aktifkan modul tertentu buat sementara
while true do
led.toggle(2, 2)
LED akan berkelip tanpa henti.
if true then
plot 0 0
Ujian cepat untuk lihat LED hidup.
while true do
radio.sendNumber(1)
if (gesture shake) then
show icon Happy
else if true then
show icon Sad
Blok “else if true” berfungsi seperti else – bagian ini akan jalan apabila syarat pertama salah.
"TRUE" = SYARAT BENAR.
Bila blok TRUE digunakan, ia bermaksud keadaan itu sentiasa betul, tanpa bergantung pada sensor, input atau nilai pembolehubah.
Variables (pembolehubah) ialah ruang simpanan data dalam program.
Ia menyimpan nilai seperti nombor, teks atau keadaan tertentu supaya micro:bit boleh menggunakan nilai itu kemudian.
Bahagian Variables dalam MakeCode memberikan semua blok untuk:
mencipta pembolehubah baharu
menyimpan nilai
menukar nilai
menggunakan nilai dalam pengiraan
memastikan program mengingat data sebelum ini
Menu Variables digunakan untuk mengurus pembolehubah dalam program. Dari sinilah cikgu boleh:
Contoh nama:
score
langkah
suhu
kira
buttonCount
Ini sangat penting untuk projek yang perlukan nombor berubah-ubah.
Blok ini digunakan untuk memberikan nilai permulaan kepada pembolehubah.
Contoh:
set score to 0
Untuk menambah atau mengurangkan sesuatu nilai dalam pembolehubah.
Contoh:
change score by 1
Digunakan untuk kiraan mata, langkah, masa, dsb.
Cikgu boleh guna nilai itu di dalam blok lain, contohnya:
memaparkan nombor
membuat perbandingan
kawal LED
hantar radio
Contoh:
show number score
micro:bit tidak mempunyai “ingatan kekal”, tapi pembolehubah membantu simpan maklumat semasa program berjalan.
Tanpa pembolehubah:
micro:bit tak boleh ingat kiraan
tak boleh buat permainan (score, health)
tak boleh kawal gelung secara dinamik
tak boleh simpan data sensor
tak boleh buat sistem logik kompleks
set score to 0
on button A pressed:
change score by 1
show number score
set tempoValue to 120
change tempoValue by 20
set tempo to tempoValue bpm
set suhu to input.temperature()
show number suhu
set jarak to sonar.distance()
if jarak < 10 then
stop motor
for index from 0 to maxValue:
plot index 0
VARIABLE = TEMPAT SIMPAN NILAI
Micro:bit gunakan pembolehubah supaya ia boleh mengingat nombor atau teks dalam program.
Blok ini digunakan dalam kategori Variables (Pembolehubah) dalam MakeCode.
Blok set LANGKAH to 0 digunakan untuk memberikan nilai baharu kepada pembolehubah bernama LANGKAH.
Ia melakukan dua perkara utama:
Biasanya digunakan di awal program untuk menetapkan LANGKAH = 0 sebelum program mula berjalan.
Contoh:
LANGKAH digunakan sebagai kiraan langkah robot, kiraan tekanan butang, atau pergerakan animasi.
Tanpa menetapkan nilai, pembolehubah mungkin mengandungi nilai rawak.
Blok ini menggantikan nilai lama dalam LANGKAH dengan nilai baharu (dalam contoh ini: 0).
Maknanya:
Jika sebelum ini LANGKAH = 10
Selepas blok ini dijalankan: LANGKAH = 0
Kerana ia memastikan pembolehubah sentiasa berada pada nilai yang betul sebelum digunakan.
Contoh kegunaan:
set LANGKAH to 0
Digunakan sebelum mula bergerak, supaya kiraan langkah bermula dari 0.
set LANGKAH to 0 // skor bermula dari kosong
Jika LANGKAH digunakan sebagai penunjuk frame animasi LED.
set LANGKAH to 0
on button A pressed:
change LANGKAH by 1
show number LANGKAH
on button B pressed:
set LANGKAH to 0
Blok set LANGKAH to ... digunakan untuk menetapkan nilai baharu kepada pembolehubah LANGKAH. Ia mengawal data yang ingin micro:bit ingat dan gunakan.
Blok ini digunakan untuk mengubah nilai pembolehubah (variable) bernama LANGKAH dengan menambah atau menolak sesuatu nilai.
Maknanya:
Jika LANGKAH = 0 → selepas blok ini dijalankan, LANGKAH = 1
Jika LANGKAH = 5 → selepas blok ini dijalankan, LANGKAH = 6
Jika LANGKAH = 10 → selepas blok ini dijalankan, LANGKAH = 11
Ia menambah nilai lama dengan nilai baharu (contoh: +1).
Blok ini sebenarnya melakukan operasi matematik:
LANGKAH = LANGKAH + 1
Tetapi dalam bentuk blok, ia lebih mudah dan ringkas.
Contoh:
on button A pressed:
change LANGKAH by 1
Setiap kali murid tekan butang A, LANGKAH meningkat 1.
Setiap kali robot melangkah, LANGKAH = LANGKAH + 1.
LANGKAH digunakan sebagai posisi X pada LED display:
plot x LANGKAH y 2
change LANGKAH by 1
Dalam game micro:bit, anda boleh tambah skor setiap kali pemain menang.
change LANGKAH by 1
set LANGKAH to 0
on button A pressed:
change LANGKAH by 1
show number LANGKAH
set LANGKAH to 0
forever:
plot x LANGKAH y 2
pause 200
unplot x LANGKAH y 2
change LANGKAH by 1
if LANGKAH > 4 then
set LANGKAH to 0
Blok change LANGKAH by … digunakan untuk menaikkan atau menurunkan nilai pembolehubah secara automatik. Ia menambah nilai lama dengan nilai baharu.
Blok ini mewakili nilai semasa bagi pembolehubah bernama LANGKAH dalam MakeCode.
Ia adalah blok pembolehubah (variable block) yang digunakan untuk:
membaca nilai LANGKAH,
menggunakan nilai tersebut dalam pengiraan,
memaparkan nilai LANGKAH,
membuat keputusan (if-statement),
atau mengawal pergerakan / animasi.
Blok ini tidak menukar nilai LANGKAH —
Ia hanya mengambil (read) dan memaparkan nilai semasa yang telah disimpan di dalam pembolehubah LANGKAH.
Contohnya, jika LANGKAH = 5, maka blok ini mewakili angka 5 dalam program.
Kerana pembolehubah adalah “kotak simpanan data” dalam program.
Blok ini digunakan untuk mengambil data dari kotak itu.
📌 Ia digunakan apabila program perlukan nilai semasa LANGKAH untuk sesuatu tugas.
show number LANGKAH
Jika LANGKAH = 3, micro:bit akan paparkan “3”.
plot x LANGKAH y 2
Jika LANGKAH = 4 → LED di baris 2, lajur 4 menyala.
set jumlah to LANGKAH + 2
Jika LANGKAH = 5 → jumlah = 7.
if LANGKAH > 10 then
show icon Heart
Jika LANGKAH melebihi 10, tunjukkan ikon hati.
LANGKAH biasanya digunakan sebagai counter (pengira langkah).
Contoh:
change LANGKAH by 1
plot x LANGKAH y 0
Setiap ulang, LANGKAH naik 1 → titik bergerak ke kanan.
Blok LANGKAH digunakan untuk mengambil nilai di dalam pembolehubah ‘LANGKAH’. Ia hanya membaca nilai, bukan menukarnya.
Blok yang cikgu tunjukkan itu bukan blok arahan, tetapi kategori utama dalam MakeCode bernama Math. Ia mengandungi semua blok yang berkaitan dengan pengiraan, nombor, dan operasi matematik untuk digunakan dalam projek micro:bit.
Kategori Math sangat penting kerana kebanyakan projek elektronik, robotik dan sensor memerlukan:
✔ pengiraan
✔ pembandingan nilai
✔ penghasilan nombor rawak
✔ operasi tambah, tolak, darab, bahagi
✔ pembulatan nombor
✔ fungsi lanjutan (modulus, punca kuasa dua, trigonometri)
• Untuk menetapkan nilai seperti 0, 1, 10, 100, atau apa-apa nombor.
• Digunakan dalam set variable, loop, sensor reading dan banyak lagi.
Contoh blok:
0 + 0
0 - 0
0 × 0
0 ÷ 0
Kegunaan:
• Mengira jarak sensor, kelajuan motor, kiraan skor, timer dan sebagainya.
Blok: pick random 0 to 10
Kegunaan:
• Buat permainan dadu, teka nombor, simulasi, pilih tindakan secara rawak.
Blok: 0 < 0, 0 = 0, 0 > 0
Digunakan dalam if-else, contohnya:
• bila suhu > 30°C hidupkan kipas
• bila cahaya < 50 hidupkan lampu
and
or
not
Kegunaan:
• Menyemak banyak syarat dalam satu masa
Contoh: jika suhu > 30 dan kelembapan < 50 → hidupkan sistem
Contoh blok:
sqrt() — punca kuasa dua
abs() — nilai mutlak
round() — pembundaran
floor() — lantai
ceil() — siling
Kegunaan:
• Menstabilkan bacaan sensor supaya tidak “melompat-lompat”
• Mengira nilai lebih kompleks dalam robotik
Contoh: 0 % 2
Kegunaan:
• Menentukan nombor ganjil/genap
• Membuat corak LED berulang
• Pengiraan masa kitaran
Blok Math ialah “kotak alat pengiraan” dalam MakeCode.
Ia digunakan untuk:
✔ mengawal sensor
✔ mengawal motor/servo
✔ membuat logik keputusan
✔ mencipta permainan
✔ memproses data
✔ melakukan kiraan dalam projek robotik atau IoT
Tanpa kategori Math, hampir semua projek micro:bit tak boleh berfungsi dengan tepat.
Blok ini ialah blok operasi matematik (Math Operator Block) dalam MakeCode.
Ia digunakan untuk membuat pengiraan matematik antara dua nilai.
Blok ini ada 3 bahagian penting:
• Tempat isi nilai pertama (contoh: 5, suhu, pemboleh ubah).
• Boleh diganti dengan apa sahaja seperti nombor, bacaan sensor atau variable.
• Tempat pilih jenis operasi matematik:
+ → Tambah
− → Tolak
× → Darab
÷ → Bahagi
• Cikgu boleh tekan tanda (▼) untuk tukar operasi.
• Tempat isi nilai kedua untuk dikira.
Blok ini akan mengira hasil operasi antara dua nilai, kemudian memberi output sebagai satu nilai nombor.
Contoh:
Jika cikgu set:
Kotak kiri = 10
Operasi = ×
Kotak kanan = 2
Output = 20
Blok ini sangat penting dalam banyak situasi:
Contoh:
Sensor suhu baca 28°C.
Cikgu mahu tukar kepada Fahrenheit:
(temperature × 9 ÷ 5) + 32
Contoh:
Kelajuan motor = (bacaan cahaya × 2)
Contoh:
score = score + 1
Contoh:
(x + y) untuk tentukan lokasi LED yang menyala.
Contoh:
counter = counter - 1
Contoh penggunaan:
let jumlah = 0
jumlah = 7 + 3
basic.showNumber(jumlah)
Output pada micro:bit → 10
Blok ini berfungsi untuk:
Tanpa blok ini, hampir semua logik pengiraan dalam projek MakeCode tidak dapat dijalankan.
Blok ini ialah blok operasi matematik tolak dalam kategori Math pada MakeCode micro:bit.
Ia digunakan untuk:
✅ Menolak (subtract) satu nilai dengan nilai yang lain
dan menghasilkan output nombor (numeric output)
Blok ini terdiri daripada 3 bahagian utama:
• Nilai atau pemboleh ubah yang akan dijadikan nilai awal.
• Contoh: 10, suhu, bacaan sensor, skor, bacaan potensiometer.
• Menunjukkan operasi yang sedang dipilih ialah tolak.
• Walaupun boleh ditukar ke operasi lain (melalui menu ▼), dalam gambar cikgu → ia sedang berada dalam mod TOLAK.
• Nilai yang akan ditolak daripada nilai pertama.
• Contoh: 1, 5, bacaan sensor lain, countdown, dsb.
Blok ini akan mengira:
[nilai kiri] – [nilai kanan]
Contoh:
Jika atas kiri = 10
Atas kanan = 3
Output = 7
Blok tolak sangat penting dalam banyak situasi. Antara kegunaan sebenar:
Contoh:
masa = masa - 1
Digunakan untuk timer permainan, jam randik (stopwatch), atau kiraan detik buzzer.
Contoh:
(suhu sekarang – suhu minimum)
(jarak max – jarak sensor)
(nilai potensiometer – offset)
Digunakan dalam kalibrasi sensor.
Contoh game micro:bit:
lives = lives - 1
Contoh:
Kelajuan = 100 - bacaan cahaya
(Semakin gelap → semakin laju motor)
Contoh:
(5 – x) untuk animasi LED terbalik.
let kira = 0
kira = 10 - 4
basic.showNumber(kira)
Output: 6
Blok ini berfungsi untuk:
Ringkasnya: blok ini ialah “blok tolak” yang digunakan untuk sebarang operasi pengurangan dalam projek micro:bit.
Blok ini ialah blok operasi matematik “DARAB” (MULTIPLICATION) dalam kategori Math pada MakeCode micro:bit.
Ia digunakan untuk:
✅ Mendarabkan dua nilai (contoh: nombor, pemboleh ubah, bacaan sensor)
dan menghasilkan output dalam bentuk nombor.
Blok ini mempunyai 3 bahagian penting:
• Ini ialah nilai awal yang akan didarabkan.
• Boleh jadi:
nombor (contoh: 5, 10, 100)
pemboleh ubah (contoh: score, speed)
bacaan sensor (cahaya, suhu, jarak)
• Menandakan operasi darab.
• Simbol boleh ditukar kepada operasi lain (melalui ▼), tetapi dalam gambar cikgu → ia sedang berada dalam mod DARAB.
• Nilai yang akan didarabkan dengan nilai pertama.
• Contohnya:
darab 2
darab 10
darab bacaan sensor lain
darab pemboleh ubah
Ia menjalankan pengiraan:
[nilai kiri] × [nilai kanan]
Contoh:
Jika kiri = 4, kanan = 3
Output = 12
Blok darab sangat penting dalam banyak projek robotik, sensor dan permainan.
Sensor biasanya beri nilai kecil. Kita darab untuk dapatkan bacaan lebih besar.
Contoh:
(bacaan cahaya × 5)
(bacaan jarak × 2)
Contohnya:
kelajuan = potensiometer × 10
(jarak × 4) untuk tentukan sudut servo.
Contoh:
score = score + (bonus × 2)
Contoh:
tukar saat ke milisaat: second × 1000
kira tenaga, jarak, atau nilai matematik lain.
Contoh:
(x × y) untuk buat pola matrix tertentu
(x × 2) untuk gerakan lebih pantas
Murid boleh buat aktiviti mudah seperti:
3 × 3, 4 × 5, 7 × 8 menggunakan micro:bit.
let hasil = 0
hasil = 6 * 7
basic.showNumber(hasil)
Output = 42
Blok ini berfungsi untuk:
Ringkasnya: ini ialah blok “DARAB”, sangat penting untuk logik matematik dalam projek micro:bit.
Blok ini ialah blok operasi Matematik “BAHAGI / DIVISION” dalam kategori Math di MakeCode micro:bit.
Ia digunakan untuk:
✅ Membahagikan dua nilai (nombor, pemboleh ubah, bacaan sensor)
dan menghasilkan output dalam bentuk nombor.
Ini ialah nilai pertama yang akan dibahagikan.
Boleh jadi:
• nombor
• pemboleh ubah
• bacaan sensor (seperti suhu, jarak, cahaya)
Simbol / bermaksud operasi bahagi.
Menu (▼) boleh tukar ke operasi lain, tetapi dalam gambar cikgu → ia berada dalam mod BAHAGI.
Ini nilai yang digunakan untuk membahagikan nilai pertama.
Contoh: bahagi 2, bahagi 10, bahagi bacaan sensor lain, dsb.
Formula blok ini:
[nilai kiri] ÷ [nilai kanan]
Contoh:
Jika kiri = 20
Jika kanan = 4
Output = 5
Blok bahagi sangat penting dalam banyak projek robotik, sensor dan game.
Contoh:
(mv ÷ 1000) → tukar milivolt kepada volt
(suhu ÷ 2) → menstabilkan bacaan
Contoh:
speed = potensiometer ÷ 2
(Jika bacaan sensor terlalu besar)
Contoh ambil 3 bacaan suhu:
(suhu1 + suhu2 + suhu3) ÷ 3
Ini penting untuk stabilkan bacaan sensor supaya tidak “melompat”.
Contoh:
(jarak ÷ 10)
(kiraan langkah ÷ 60) → langkah per saat
Contoh:
(x ÷ 2) untuk perlahan pergerakan animasi
(bacaan cahaya ÷ 5) untuk sesuaikan tahap brightness
Boleh digunakan untuk aktiviti pembelajaran murid Tahun 6.
Contoh:
20 ÷ 4 = ?
Micro:bit kira dan paparkan jawapan.
let hasil = 0
hasil = 40 / 5
basic.showNumber(hasil)
Output = 8
Jika cikgu buat:
10 ÷ 0
Micro:bit tidak boleh kira dan boleh menyebabkan ralat.
Blok bahagi berfungsi untuk:
Ringkasnya: blok ini ialah “blok BAHAGI” yang digunakan untuk apa-apa operasi pembahagian dalam MakeCode.
Blok ini digunakan untuk mengira:
BAKI (REMAINDER / MODULUS)
daripada satu operasi pembahagian.
Dalam Matematik, operasi ini dipanggil modulus atau MOD.
Contoh mudah:
7 ÷ 3 = 2 baki 1
→ baki 1 itulah yang dikira oleh blok ini.
Blok terdiri daripada:
Ini ialah pembilang / numerator
Contoh: 7, 10, 25, bacaan sensor, pemboleh ubah.
Menunjukkan operasi pembahagian.
Ini ialah penyebut / denominator
Contoh: 2, 3, 5, atau mana-mana nilai.
Blok akan kira:
baki = nilai pertama MOD nilai kedua
Ia mengambil baki hasil pembahagian.
Contoh:
remainder of 10 / 4
10 ÷ 4 = 2 baki 2
Output blok → 2
Ramai murid ingat baki hanya untuk Matematik Tahun 4–6, tapi dalam programming ia sangat penting.
Berikut kegunaan praktikalnya:
Gunakan kesan:
Jika (number % 2 == 0) → nombor genap
Jika (number % 2 == 1) → nombor ganjil
Dalam MakeCode:
remainder of x / 2
Jika baki 0 → genap
Jika baki 1 → ganjil
Ini sangat sesuai untuk game atau animasi LED.
Contoh animasi blink LED:
Setiap 2 langkah, ubah LED
→ (step % 2)
Contoh:
Kelipkan LED setiap 3 saat
→ (seconds % 3 == 0)
Contoh:
Robot belok kiri setiap 4 langkah
Robot belok kanan setiap 2 langkah
Gunakan:
remainder of steps / 4
Jika baki = 0 → buat tindakan tertentu
Contoh:
if (i % 5 == 0) {
buat sesuatu setiap 5 pusingan
}
Contoh:
index = (index + 1) % 5
Berguna untuk:
• senarai LED
• senarai lagu
• animasi menu
let baki = 0
baki = 10 % 3
basic.showNumber(baki)
Output = 1
Jika penyebut = 0, sistem tidak boleh mengira.
Blok remainder of … / … digunakan untuk:
Ringkasnya: blok ini ialah “MODULUS”, sangat penting dalam logik programming.
Blok ini ialah fungsi Matematik min/max yang terdapat dalam kategori Math di MakeCode micro:bit.
Ia digunakan untuk mencari:
nilai minimum (min) ATAU
nilai maksimum (max)
daripada dua nombor.
Dalam gambar cikgu, ia sedang berada pada mod “min” (minimum).
Blok terdiri daripada 3 bahagian utama:
• Jika pilih min → blok akan mencari nilai paling kecil.
• Jika pilih max → blok akan mencari nilai paling besar.
Cikgu boleh tekan ▼ untuk tukar antara dua fungsi ini.
Ini boleh jadi:
• nombor tetap (5, 20, 100)
• pemboleh ubah (score, suhu, jarak)
• bacaan sensor (light level, temperature)
Sama seperti kotak kiri, ia boleh diisi dengan apa-apa nilai.
Jika mod = min
output = nilai yang lebih kecil
Jika mod = max
output = nilai yang lebih besar
Contoh (untuk min):
min of 8 and 3 → output: 3
Contoh (untuk max):
max of 8 and 3 → output: 8
Ia digunakan dalam projek:
✔ robotik
✔ game
✔ sensor
✔ kawalan motor
✔ kalibrasi bacaan
✔ pastikan nilai tidak “lari” dari julat tertentu
Kadang-kadang bacaan sensor terlalu tinggi atau melompat.
Boleh gunakan fungsi ini untuk stabilkan data.
Contoh:
brightness = min of (light level) and 100
Jika bacaan cahaya 180 → ia akan dikunci kepada 100 sahaja.
Contoh:
Jangan bagi kelajuan motor jadi negatif.
speed = max of (potentiometer - 20) and 0
→ Jika hasil kiraan kurang dari 0, ia akan tetap menjadi 0.
Contoh:
angle = min of angle and 180
→ Elakkan servo pergi lebih dari 180°.
Contoh: ambil bacaan sensor paling rendah antara 2 sensor.
Contoh:
highest = max of highest and currentScore
Contoh:
x = min of x and 4
Elak LED bergerak keluar dari grid 5×5.
let kecil = 0
kecil = Math.min(8, 3)
basic.showNumber(kecil)
Output = 3
Untuk max:
besar = Math.max(8, 3)
basic.showNumber(besar)
Output = 8
Blok ini digunakan untuk:
Ringkasnya: blok ini menentukan NILAI TERKECIL atau TERBESAR daripada dua nombor untuk memastikan program berjalan selamat & stabil.
Blok ini ialah fungsi Matematik “absolute value” (nilai mutlak) dalam kategori Math di MakeCode micro:bit.
Ia digunakan untuk menukar nombor negatif menjadi positif, manakala nombor positif akan kekal positif.
Nilai mutlak bermaksud:
Jarak sesuatu nombor daripada sifar tanpa mengambil kira tanda positif atau negatif.
Contoh:
|−5| = 5
|5| = 5
|0| = 0
Blok ini mengambil satu nilai, kemudian:
Jika nombor itu negatif, ia akan ditukar menjadi positif
Jika nombor itu positif, ia dikekalkan
Jika nombor itu 0, output tetap 0
Contoh:
absolute of –12 → 12
absolute of 8 → 8
absolute of 0 → 0
Kerana banyak bacaan sensor atau pengiraan boleh menghasilkan nilai negatif, tetapi:
✔ motor tidak boleh eksekusi nilai negatif
✔ LED brightness tidak boleh negatif
✔ jarak/halaju mesti sentiasa positif
✔ animasi sering memerlukan angka positif sahaja
Jadi fungsi absolute digunakan untuk membuang tanda negatif supaya nilai selamat digunakan.
Kadang-kadang sensor seperti accelerometer memberi bacaan negatif & positif.
Jika kita hanya perlukan magnitud (saiz nilai), gunakan:
abs of acceleration
Motor tak boleh guna nilai negatif.
Contoh:
speed = absolute of (light_level - 128)
Robot kadang bergerak ke depan dan belakang, tetapi kita hanya mahu tahu:
berapa jauh ia bergerak?
Jadi gunakan:
distance = absolute of position
Contoh jika murid teka nombor:
difference = absolute of (guess - answer)
Murid boleh tahu berapa jauh “jarak” dari jawapan sebenar.
Contoh:
x = absolute of x
Untuk pastikan nombor tidak negatif (LED matrix tidak ada koordinat negatif)
let nilai = 0
nilai = Math.abs(-15)
basic.showNumber(nilai)
Output = 15
Blok absolute of digunakan untuk:
Ringkasnya: nilai mutlak memastikan semua nilai kekal POSITIF supaya program micro:bit lebih stabil & selamat.
Blok ini ialah fungsi Matematik lanjutan dalam kategori Math di MakeCode micro:bit.
Ia digunakan untuk mengira:
Punca kuasa dua (square root) bagi satu nilai.
Punca kuasa dua bermaksud:
Nombor yang bila didarab dengan dirinya, menghasilkan nilai asal.
Contoh:
√25 = 5 → sebab 5 × 5 = 25
√9 = 3 → sebab 3 × 3 = 9
Blok ini ada:
— square root (punca kuasa dua)
— logarithm
— exponential
— trigonometric (bergantung versi MakeCode)
Dalam gambar cikgu, ia sedang berada pada fungsi square root.
Tempat cikgu isi nombor atau pemboleh ubah.
Contoh:
nombor tetap (25, 36, 81)
bacaan sensor
variable (jarak, waktu)
Blok ini akan mengira:
Square root of [nilai]
Contoh:
square root of 49 → 7
square root of 16 → 4
square root of 2 → 1.414 (nilai perpuluhan)
Jika nilai negatif → square root tidak wujud dalam nombor nyata.
Micro:bit biasanya akan hasilkan NaN (Not a Number).
Walaupun ini fungsi Matematik lanjutan, ia sangat berguna dalam projek:
Accelerometer memberi bacaan X, Y, Z.
Untuk tahu seberapa kuat gegaran:
Formula:
magnitude = √(x² + y² + z²)
Dalam MakeCode:
darab
tambah
square root
Digunakan dalam:
• projek gempa bumi
• pengesan pergerakan
• latihan sukan
Jika cikgu buat sistem koordinat untuk game atau robot:
Formula Matematik:
Jarak = √((x2 – x1)² + (y2 – y1)²)
Digunakan untuk:
• game shooting
• game maze
• robot navigate grid
Square root digunakan untuk "menghaluskan" data bacaan sensor.
Contoh:
scaled_value = √lightLevel
Ini menjadikan data lebih stabil dan “smooth”.
Dalam projek robotik atau STEM:
• v = √(u² + 2as)
• jarak brek robot
• simulasi projek pelajar
Murid Tahun 6 boleh belajar Matematik:
— punca kuasa dua
— nombor kuasa dua
— masalah operasi asas Matematik
let hasil = 0
hasil = Math.sqrt(81)
basic.showNumber(hasil)
Output = 9
Jika cikgu buat:
square root of –25
Micro:bit tidak boleh kira kerana square root nombor negatif tiada dalam nombor nyata.
Blok "square root" digunakan untuk:
Ringkasnya: blok ini ialah “punca kuasa dua” yang sangat berguna untuk projek STEM dan sensor.
Blok ini ialah fungsi Matematik pembundaran (rounding) dalam kategori Math di MakeCode micro:bit.
Ia digunakan untuk:
Menukarkan nombor perpuluhan (decimal) kepada nombor bulat (integer).
Blok ini ada dua komponen:
Cikgu boleh tukar kepada beberapa fungsi:
round → pembundaran biasa
floor → bundar ke bawah
ceiling → bundar ke atas
truncate → buang perpuluhan, tak membundar
Dalam gambar cikgu → fungsi yang dipilih ialah round.
Tempat untuk masukkan:
nombor perpuluhan
bacaan sensor (selalunya decimal)
hasil kiraan (contoh: bahagi, punca kuasa dua)
pemboleh ubah apa-apa
Ia mengikut peraturan pembundaran Matematik standard:
Contoh:
3.1 → 3
7.49 → 7
2.2 → 2
Contoh:
3.5 → 4
7.8 → 8
2.9 → 3
Contoh:
10 → 10
4 → 4
Micro:bit sering menghasilkan nilai perpuluhan dalam:
Tetapi micro:bit:
❌ tidak boleh paparkan perpuluhan di LED
❌ sensor/motor/servo perlukan nilai bulat sahaja
Jadi pembundaran (rounding) sangat diperlukan dalam banyak situasi.
Sensor accelerometer beri nilai decimal seperti 987.23
Gunakan:
round of acceleration
Supaya LED paparkan nombor bulat 987 sahaja.
Servo hanya menerima sudut 0–180° dan mesti bulat.
Contoh:
angle = round of (sqrt(x² + y²))
Jika bonus melibatkan operasi bahagi:
score = score + round of (bonus / 3)
LED koordinat mesti bulat (0–4).
Jadi kita bundarkan sebelum guna.
Untuk projek IoT atau data analysis.
let nilai = 0
nilai = Math.round(4.67)
basic.showNumber(nilai)
Output = 5
round(4.2) = 4
truncate(4.9) = 4
round(4.6) = 5
Blok round of digunakan untuk:
Ringkasnya: blok ini memastikan nombor decimal jadi nombor bulat yang bersih dan stabil untuk digunakan dalam program micro:bit.
Blok ini berada dalam kategori Math dan digunakan untuk:
Menjana nombor rawak (random number) di antara dua nilai yang cikgu tetapkan.
Ia akan memilih satu nombor secara rawak, termasuk nombor awal dan nombor akhir.
Blok ini mengandungi:
— Nilai paling kecil yang mungkin dipilih
Contoh: 0, 1, 5, –10, dsb.
— Nilai paling besar yang mungkin dipilih
Contoh: 5, 10, 100, 255, dsb.
✔ Range adalah inklusif (termasuk kedua-dua hujung)
Contoh:
pick random 0 to 10
Boleh keluarkan:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
✔ Hasil sentiasa nombor bulat (integer)
Micro:bit tidak menghasilkan perpuluhan dalam random.
✔ Setiap keputusan berbeza-beza setiap kali kod berjalan
→ Sesuai untuk permainan & simulasi.
Blok random ini sangat banyak digunakan dalam projek micro:bit kerana ia memberi kesan tidak dapat dijangka (unpredictable).
Berikut antara penggunaan praktikal:
Contoh:
micro:bit pilih nombor rawak 1–6 seperti dadu elektronik
permainan teka nombor
permainan arah rawak (atas, bawah, kiri, kanan)
Contohnya:
LED menyala di kedudukan rawak
corak "lampu berkelip" (sparkle effect)
Kod:
plot pick random 0 to 4 , pick random 0 to 4
Contoh:
Robot pilih arah rawak (kiri/kanan)
Kelajuan rawak
Jarak rawak
Contoh:
hujan rawak
suhu rawak
densiti data rawak
Boleh ganti sensor dengan nombor rawak sebelum sambungan sebenar dipasang.
Digunakan untuk buat:
muzik rawak
kesan bunyi permainan
music.playTone(pick random 200 to 1000, 200)
Boleh guna untuk:
latihan soalan darab rawak
soalan tambah rawak
kuiz matematik
let nombor = 0
nombor = randint(0, 10)
basic.showNumber(nombor)
Output = nombor rawak antara 0 hingga 10, termasuk kedua-duanya.
Jika cikgu buat terbalik:
pick random 10 to 0
Micro:bit tetap berfungsi, tetapi akan swap nilai di belakang layar.
Jika cikgu perlukan perpuluhan, kena buat sendiri:
pick random 1 to 100 ÷ 10 → dapat 0.1 hingga 10.0
Blok pick random digunakan untuk:
Ringkasnya: blok ini memberi elemen “kejutan” dan variasi dalam projek micro:bit.
Blok ini digunakan untuk:
MENGHADKAN sesuatu nilai supaya kekal dalam satu julat (range) tertentu.
Dalam bahasa mudah:
✔ Jika nilai terlalu rendah → ia akan naik ke nilai minimum
✔ Jika nilai terlalu tinggi → ia akan turun ke nilai maksimum
✔ Jika nilai berada dalam julat → ia kekal seperti biasa
Blok ini mempunyai 3 input:
Contoh: bacaan sensor, kelajuan, sudut servo, skor, timer.
Nilai paling rendah yang dibenarkan.
Nilai paling tinggi yang dibenarkan.
Formula operasi:
constrain(value, min, max)
Contoh mudah:
constrain 2 between 5 and 10 → 5
constrain 15 between 5 and 10 → 10
constrain 8 between 5 and 10 → 8
Output sentiasa berada antara 5 hingga 10 sahaja.
Dalam projek dunia sebenar, bacaan sensor atau pengiraan boleh:
❌ melompat
❌ negatif
❌ menjadi terlalu besar
❌ merosakkan servo/motor
❌ menyebabkan program rosak
Jadi fungsi constrain digunakan untuk memastikan nilai sentiasa selamat.
Servo hanya menerima nilai 0 hingga 180.
angle = constrain(angle, 0, 180)
Jika kod tersilap hasilkan nilai 250 → ia akan diturunkan ke 180.
Motor biasanya guna nilai 0–255.
speed = constrain(speed, 0, 255)
Jika speed = –30 → jadi 0
Jika speed = 400 → jadi 255
Sensor cahaya micro:bit = 0–255, tetapi kadang memberi bacaan pelik (noise).
Gunakan:
light = constrain(lightLevel(), 0, 255)
Koordinat LED mesti antara 0–4.
x = constrain(x, 0, 4)
y = constrain(y, 0, 4)
Ini mengelakkan animasi tersekat atau error.
Contoh:
score = constrain(score, 0, 100)
Jika bacaan sensor darab menghasilkan nombor besar, constrain boleh mengecilkannya.
let nilai = 0
nilai = Math.constrain(120, 0, 100)
basic.showNumber(nilai)
Output = 100
Jika cikgu isi terbalik, micro:bit tetap berfungsi tetapi hasil mungkin tidak logik.
Ia hanya menghadkan nilai, bukan mengubah cara sensor mengukur.
Blok constrain … between … and … digunakan untuk:
Ringkasnya: blok constrain memastikan nilai sentiasa berada dalam “zon selamat” yang cikgu tetapkan.
Blok ini digunakan untuk:
MENUKAR (MENYUSUNKAN SEMULA) satu nilai daripada satu julat asal ke julat baharu.
Dalam istilah matematik dan robotik, ini dipanggil value mapping atau scaling.
map [nilai] from low [A] high [B]
to low [C] high [D]
Maknanya:
Nilai [nilai] berada dalam julat A → B
Tukar (skala) nilai itu ke julat C → D
Formula matematik:
[
Output = C + \frac{(value - A)(D - C)}{(B - A)}
]
Micro:bit akan kira secara automatik.
Paip baca 0–1023
LED hanya guna 0–4
Gunakan:
x = map(sensor, 0, 1023, 0, 4)
Cahaya = 0–255
Servo = 0–180
Menggunakan:
servo = map(light, 0, 255, 0, 180)
Joystick = 0–1023
Kelajuan motor = –255 hingga 255
Mapping:
speed = map(joystick, 0, 1023, -255, 255)
Bunyi = 0–255
LED brightness = 0–9
brightness = map(soundLevel, 0, 255, 0, 9)
Jika suhu dari 20°C hingga 40°C
Tapi bar graf LED 0–5
bar = map(temp, 20, 40, 0, 5)
let sensor = pins.analogReadPin(AnalogPin.P0)
let ledPos = Math.map(sensor, 0, 1023, 0, 4)
led.plot(ledPos, 2)
Jika nilai asal melebihi julat, output boleh jadi di luar julat baharu.
Jika mahu hadkan, kena tambah constrain():
map → constrain
Jika A > B atau C > D, perlu pastikan penggunaan betul.
Output mungkin perpuluhan, kena guna round() jika mahu integer.
Blok map() digunakan untuk:
Ringkasnya: blok MAP adalah “mesin penukar nilai” yang sangat penting dalam projek micro:bit.
Blok “pick random true or false” digunakan untuk:
Menjana satu nilai rawak jenis Boolean, iaitu sama ada
✔ true (betul/ya) atau
✔ false (salah/tidak)
Ia memberikan keputusan secara rawak dengan kebarangkalian 50%–50%.
Dalam MakeCode, Boolean digunakan dalam logik seperti:
if ... then
while ...
syarat perbandingan
kawalan robot
permainan (game logic)
Boolean ialah nilai logik yang mempunyai dua sahaja kemungkinan:
true → benar
false → salah
Blok ini memilih salah satu daripada dua nilai tersebut secara rawak.
Setiap kali blok ini dijalankan:
Micro:bit akan menjana nombor rawak 0 atau 1.
Jika hasil = 0 → hasilnya false
Jika hasil = 1 → hasilnya true
Oleh itu:
✔ peluang dapat “true” = 50%
✔ peluang dapat “false” = 50%
Blok ini sangat berguna untuk:
membuat keputusan rawak
game yang memerlukan unsur "kejutan"
animasi rawak
robot bergerak secara tidak dijangka
simulasi matematik kebarangkalian
Ia menjadikan program lebih dinamik, ** menyeronokkan** dan tidak statik.
if pick random true or false then
belok kiri
else
belok kanan
Robot akan bergerak secara unpredictable.
True = kepala, False = ekor
if pick random true or false then
tunjuk ikon kepala
else
tunjuk ikon ekor
if pick random true or false then
LED on
else
LED off
Contoh untuk game:
musuh muncul atau tidak
jalan kiri atau kanan
lompat atau duduk
Micro:bit boleh pilih jawapan rawak:
true → Betul
false → Salah
Guru boleh ajar murid konsep probability:
50/50 chance
eksperimen rawak
statistik
let hasil = false
hasil = Math.randomBoolean()
if (hasil) {
basic.showIcon(IconNames.Yes)
} else {
basic.showIcon(IconNames.No)
}
Output: micro:bit akan tunjuk ✔ atau ✖ secara rawak.
Blok “pick random true or false”:
Ringkasnya: blok ini memberi keputusan 50-50 secara rawak dalam bentuk true atau false.
Blok ini ialah blok pemalar matematik (math constant) dalam kategori Math di MakeCode.
Ia memberikan nilai π (pi) iaitu nombor matematik istimewa:
[
\pi \approx 3.141592653589793
]
Nilai π adalah tetap (constant) dan tidak berubah.
π digunakan dalam semua kiraan berkaitan:
bulatan
lengkok
jejari (radius)
diameter
luas bulatan
lilitan bulatan
Formula matematik utama:
[
C = 2\pi r
]
[
A = \pi r^2
]
Menu dalam blok ini (▼) membolehkan cikgu memilih pelbagai pemalar matematik lain seperti:
✔ π (pi)
✔ e (Euler’s number)
✔ φ (phi – golden ratio)
✔ √2
✔ √½
✔ log base constants
(Pilihan bergantung kepada versi MakeCode)
Tetapi dalam gambar cikgu, simbol π sedang digunakan.
Walaupun micro:bit bukan kalkulator sains, nilai π sangat berguna bagi projek:
Jika mahu kira berapa jarak robot bergerak:
[
\text{Jarak} = 2\pi r
]
Digunakan jika robot guna roda.
Contoh:
kira luas bulatan
kira lilitan
anggar nilai π
banding diameter vs lilitan
Micro:bit boleh paparkan hasil pengiraan.
Kadang-kadang accelerometer menghasilkan nilai dalam radian.
Contoh:
angle = (acceleration / max) * π
Fungsi sin(), cos(), tan() dalam MakeCode biasanya guna radian.
π digunakan untuk tukar darjah → radian.
Formula:
[
\text{radian} = \frac{\pi}{180} \times \text{degree}
]
Untuk buat corak putaran LED.
let r = 5
let luas = Math.PI * r * r
basic.showNumber(luas)
Output = anggaran luas bulatan bagi radius 5.
Tetapi micro:bit hanya papar integer → jadi kena guna round() jika mahu kemaskan paparan.
Contoh:
round (π × 10) = 31
Blok π (pi) digunakan untuk:
Ringkasnya: blok ini memberikan nilai PI yang digunakan untuk semua pengiraan berkaitan bulatan dan trigonometri dalam MakeCode.