OTAK ROBOT

Untuk mengambil keputusan, robot menggunakan komputer atau mikrokontroler. Bagi mereka yang tidak terbiasa, mikrokontroler pada dasarnya adalah komponen elektronik yang dapat melakukan tiga hal. Ia dapat menginterpretasikan input dari dunia fisik, memproses informasi ini, dan mengontrol perangkat output di dunia fisik. Dalam arti dasar, mikrokontroler dapat membaca sensor, membuat keputusan, dan mengontrol lampu, speaker, dan motor.

Dengan bisa merasakan dan merespons dunia, Anda dapat membuat lingkaran umpan balik antara output dan input. Dengan kata lain, Anda dapat membuat robot dan perangkat yang benar-benar interaktif. Cara lain untuk berpikir tentang ini adalah bahwa robot dapat memperhatikan apa yang terjadi di sekitar mereka, membuat keputusan menggunakan Arduino, dan kemudian merespons secara bermakna. Dengan cara ini, mereka berperilaku sedikit seperti kebanyakan makhluk hidup lainnya.

Arduino

Arduino adalah jenis mikrokontroler yang sangat umum. Apa yang membedakan Arduino dari mikrokontroler lainnya adalah mudah digunakan, didokumentasikan dengan baik, dan memiliki komunitas online yang luas dari orang-orang yang menggunakannya. Ini berarti bahwa apa pun kesalahannya, Anda mungkin dapat menemukan solusi yang didokumentasikan secara online atau seseorang yang bersedia membantu Anda. Ini sangat bermanfaat saat memulai.

Ada sejumlah jenis Arduino yang berbeda, tetapi untuk kelas ini kita akan menggunakan Arduino Uno. Ini adalah versi mikrokontroler Arduino yang paling banyak ditemukan di mana-mana. Pada saat pelajaran ini selesai, Anda akan memiliki pemahaman singkat tentang cara menggunakan papan tulis, tetapi Anda tidak akan menjadi seorang ahli.

Meskipun Arduino memiliki banyak fitur, ada beberapa yang harus Anda perhatikan. Ada port USB yang digunakan untuk pemrograman. Ada soket daya yang digunakan untuk menyalakan Arduino saat tidak terhubung ke komputer Anda. Ada juga dua baris soket wanita di sepanjang tepi papan. Masing-masing lubang kecil ini terhubung ke sesuatu yang berbeda di papan tulis, dan melakukan fungsi yang berbeda. Mereka semua harus diberi label yang cukup baik untuk menunjukkan siapa mereka.

Jika dan ketika Anda bingung, Anda dapat menemukan gambaran yang jauh lebih mendalam dengan memeriksa Kelas Arduino .

Tancapkan.

Untuk menyalakan papan, cukup sambungkan ke komputer Anda dengan kabel USB-A ke USB-B. Ini pada dasarnya adalah kabel USB standar yang akan digunakan oleh sesuatu seperti printer komputer.

Memprogram Arduino

Untuk memprogram Arduino kita akan menggunakan Arduino IDE (lingkungan pengembangan terintegrasi). Versi perangkat lunak terbaru dapat diunduh secara gratis dari situs Arduino atau digunakan langsung di internet (segera).

Catatan Tentang Pemrograman

Yang paling penting untuk diketahui tentang pemrograman adalah memalsukannya sampai Anda berhasil. Pada dasarnya, Anda sebenarnya tidak perlu tahu cara memprogram untuk bekerja dengan kode. Ada banyak kode contoh sudah ada di luar sana. Anda hanya perlu memahami struktur dasarnya. Setelah Anda mendapatkannya, itu hanya masalah menemukan dan mengubah kode yang sudah ada. Jika Anda hanya bertahan dengan pendekatan ini, tetap berpikiran terbuka, dan semangat yang tak kenal takut, pada akhirnya Anda akan belajar memprogram seperti yang nyata.

Namun, ini tidak sepenuhnya gratis untuk semua. Ada beberapa hal yang perlu Anda pahami. Tolong tahan dengan saya sementara saya menjatuhkan beberapa pengetahuan coding yang sangat mendasar pada Anda. BAM!

Sintaksis

Setiap bahasa pemrograman memiliki sintaks untuk bagaimana kode perlu diformat. Itu pada dasarnya setara dengan mengetahui tata bahasa yang tepat. Sebagai contoh, sebagian besar ekspresi dalam pemrograman diakhiri dengan tanda titik koma - seperti itu; Ini agak seperti menulis periode di akhir kalimat. Jika Anda menulis esai tanpa periode Anda akan membingungkan heck out dari pembaca. Demikian juga, jika Anda menulis program Arduino tanpa sintaks, Anda akan membingungkan heck out dari kompiler. Kompiler mengartikan kode dan sedikit seperti pembaca esai dalam analogi kita.

Jika Anda pernah mendapatkan kesalahan aneh dan tidak tahu mengapa, kemungkinan Anda telah melanggar salah satu aturan sintaksis (yaitu pemformatan).

Ekspresi Kode

Saat membaca dan menulis kode, Anda akan menemukan beberapa blok bangunan dasar seperti halnya Anda menggunakan bahasa lain. Misalnya, bahasa Inggris memiliki kata benda, kata sifat, dan kata kerja. Komponen-komponen ini kemudian disusun menjadi kalimat. Pemrograman pada gilirannya memiliki konstanta, variabel, dan operator. Ini kemudian disusun menjadi fungsi.

Berikut adalah beberapa definisi dasar komponen pemrograman umum:

Konstanta adalah istilah yang didefinisikan sekali dan tidak berubah.

Variabel adalah istilah yang merupakan tempat penampung untuk nilai-nilai lain dan dapat berubah.

Operator adalah istilah yang melakukan tindakan, yang biasanya berupa matematika atau perbandingan logis antara nilai.

Fungsiadalah kumpulan konstanta, operator, dan variabel terstruktur. Setiap kali suatu fungsi dipanggil, ia membaca dan mengeksekusi rutin aksi spesifik yang sama.

Struktur Program

Setelah Anda menguasai komponen tata bahasa Inggris dan sudah mulai menulis kalimat, langkah logis berikutnya adalah menulis komposisi seperti esai. Seperti halnya esai yang memiliki struktur dengan paragraf pembuka, teks isi, dan paragraf penutup, demikian juga program Arduino. Namun, struktur program Arduino sedikit berbeda.

Program tipikal disusun sebagai berikut:


//####################
//###  THE HEADER  ###
//####################

// The header explains to you as a human what the program is doing
// It is not processed by the compiler
// Also note that anything preceeded by two slashes like so '//'
// is considered a comment and not processed by the compiler.
// Comments explain to you what is happening in the code.


//#####################
//###  DEFINITIONS  ###
//#####################

// Definitions are things that we want to establish globally throughout the code.
// We do this first thing before the code starts.
// It only happens once when the code runs.

// Libraries are often required to add additional functionality to the Arduino software.
// One example we will be using a lot is the servo library.
// By adding the servo library we get servo-specific commands which makes life easier.
#include <libraries.h>


// We can also define variables and constants 
// that we want to establish globally throughout the code.
// There are different types of variables and constants 
// Learn more here under 'constant' and 'data types': 
// http://www.arduino.cc/en/Reference/HomePage

// For instance, we can establish an intenger variable
int definition1;

// We can also both establish a long variable and give it a starting value.
long definition2 = 3000;

// We can also name something a constant, and give it a value which won't change
const thisIsAConstant = 2;


//################
//###  SETUP  ###
//################

void setup() {
  
  // The setup code goes here.
  // Like definitions it only runs once.
  // The difference is that in the setup you include things you want to do,
  // not things you want to define.

  // For instance, you may want to move a servo motor to it's default position

  // Or engage the Serial Monitor for debugging your code

  // Or blink an LED test pattern to let you know the application has started
  
}


//###################
//###  MAIN LOOP  ###
//###################

void loop() {
  
  // Anything put here will run over and over.
  // This is where the bulk of your code should live.
  // The Arduino will loop through whatever is here indefinately until it runs out of power.
  
}

//##############################
//###  ADDITIONAL FUNCTIONS  ###
//##############################

// If you write your own custom functions, they would be placed down here below the main loop.
// You can call these functions from either the setup or main loop.
// They are useful if you need to do a particular set of things frequently
// Instead of writing it over, and over, you can just call the function

void yourcustomfunction(){
  
  // Here is where you write your custom function
  
  // It can be a particular routine such as configuring motors
  // to drive forwards, backwards, right or left.
  
  // Or it can be a routine to check a sensor.

}

//####################
//###  THAT'S ALL  ###
//####################

// Don't worry. This is all super-confusing at first.
// This will make more sense as you do it.

Kompilator biasanya membaca dari kiri ke kanan dari satu baris ke baris berikutnya. Baik, untuk sebagian besar. Ada beberapa perbedaan utama dari cara orang normal yang penting untuk dipahami. Jika itu dalam dan dari dirinya sendiri tidak membingungkan, semua program membaca halaman - sampai batas tertentu! Dan ini penting untuk diingat ... Ketika kompiler sampai ke loop utama (), apa pun yang terkandung di dalam loop ini diulang berulang-ulang sampai Arduino kehabisan daya. Loop utama () adalah tempat berulang tanpa henti di mana daging kode harus hidup. Apa pun yang ingin Anda capai harus ada di loop utama ().

Cara yang baik untuk memikirkan program komputer agak mirip dengan memilih kisah petualangan Anda sendiri. Kompiler membaca cerita seperti yang lain, tetapi ketika kompiler membaca fungsi, alih-alih membaca baris berikutnya, ia melompat ke tempat fungsi itu hidup dan membacanya baris demi baris sebagai gantinya. Setelah selesai membaca fungsi, ia kembali ke baris berikutnya dalam kode dari tempat sebelumnya. Juga, fungsi dapat memiliki fungsi lain yang bersarang di dalamnya. Jadi, suatu fungsi, dapat mengarah ke fungsi lain, ke fungsi lain, sebelum kembali ke rutinitas utama.

Semua ini mungkin sangat membingungkan dan asing bagi Anda. Tidak apa-apa. Mempelajari bahasa pemrograman Arduino sama seperti mempelajari bahasa apa pun. Dibutuhkan waktu untuk memahami itu, dan bahkan kemudian butuh waktu lama untuk benar-benar fasih.

Untuk mempelajari lebih lanjut tentang pemrograman, tempat yang baik untuk memulai adalah Codecadamy .

Jalankan Program

Menjalankan program di Arduino sangat sederhana.

Untuk memulai, Anda harus menentukan jenis papan yang Anda gunakan. Itu mudah, pilih opsi "Arduino / Genuino Uno".

Anda juga perlu menentukan port tempat Arduino ditemukan. Itu agak rumit, tetapi tidak terlalu sulit. Cukup pilih opsi yang terlihat seperti "/dev/cu.usbmodem [angka acak]"

Buka contoh Blink dari menu Contoh 01. Dasar. Kemudian, cari tombol unggah (sepertinya panah yang menunjuk ke kanan) dan tekan. Jika semuanya dikonfigurasi dengan benar, itu akan menyebabkan LED pada papan Arduino berkedip terus.

Coba ubah nilai angka di dalam fungsi penundaan dan muat ulang kodenya. Perhatikan bahwa itu mengubah tingkat di mana ia berkedip.

Sekarang setelah Anda menyelesaikannya, mari kita coba berkedip LED eksternal yang tidak disolder langsung ke papan Arduino.

Semua Tentang Breadboards

Saat Anda perlu membuat prototipe sirkuit yang menghubungkan ke Arduino, Anda harus menggunakan papan tempat memotong roti.

Breadboard dimaksudkan untuk membuat koneksi non-permanen cepat antara komponen elektronik. Mereka tertutup lubang soket kecil yang terhubung dalam baris. Papan itu sendiri dibagi menjadi empat bagian. Ada dua bagian dalam penuh dengan baris horizontal pendek, dan dua bagian luar dengan baris vertikal yang lebih panjang.

Bagian dalam biasanya digunakan untuk menghubungkan komponen, dan bagian luar biasanya digunakan sebagai jalur bus listrik. Dengan kata lain, Anda dapat menghubungkan baterai ke salah satu jalur luar dan kemudian menghidupkan komponen di bagian dalam dengan menghubungkan kabel ke bagian ini.

Dalam grafik di atas, Anda dapat secara visual memahami bagaimana baris pada papan tempat memotong roti terhubung secara elektrik. Dua bagian dalam memiliki baris horisontal pendek diulangi di papan tulis. Dua bagian luar masing-masing memiliki dua baris vertikal panjang. Ini ditandai dengan warna merah dan biru dan dimaksudkan untuk menandakan baris untuk daya (merah) dan baris untuk tanah (biru). Tidak semua papan tempat roti ditandai dengan garis-garis seperti ini, tetapi semuanya ditata dengan cara yang sama.

Untuk informasi lebih lanjut tentang papan tempat memotong roti lihat Tutorial Breadboard ini .

Catatan Cepat tentang LED

Meskipun orang-orang menganggap LED sebagai bola lampu kecil, mereka sebenarnya sangat berbeda. LED adalah jenis komponen elektronik yang disebut dioda. Faktanya, LED adalah singkatan untuk light emitting diode.

Ada banyak yang bisa dikatakan tentang status unik mereka sebagai dioda, tetapi untuk tujuan kami satu-satunya hal yang perlu Anda ketahui adalah bahwa dioda hanya memungkinkan listrik mengalir dalam satu arah. Mereka adalah apa yang Anda sebut 'terpolarisasi'. Ada satu kaki yang harus selalu terhubung ke daya dan satu kaki yang harus terhubung ke ground. Jika Anda menghubungkannya ke belakang, daya tidak akan mengalir.

Kaki yang terhubung ke kekuasaan disebut anoda. Kaki yang terhubung ke tanah disebut katoda. Ada tiga cara untuk membedakan anoda LED dari katoda.

1) Kaki yang terhubung ke anoda biasanya lebih panjang dari kaki yang terhubung ke katoda.
2) Tubuh LED biasanya memiliki titik datar di sisi katoda.
3) Jika Anda melihat ke dalam LED, bit logam kecil yang terhubung ke kabel anoda jauh lebih kecil dari katoda.

Resistor

Resistor pada dasarnya menambah hambatan pada sebuah rangkaian. Ada banyak alasan untuk melakukan ini, tetapi saya tidak punya waktu untuk menjelaskan.

Pada dasarnya, kita memerlukan resistor di sirkuit yang akan kita bangun karena LED tidak memberikan hambatan. Jika kita menghubungkan daya melalui LED tanpa hambatan, maka pada dasarnya sama dengan membuat korsleting dengan menghubungkan catu daya ke ground. Kami menambahkan resistor secara seri ke LED untuk menghabiskan sebagian daya dan mencegah korsleting. Jika Anda ingin tahu lebih banyak, Anda dapat mempelajari lebih lanjut tentang resistor dan hambatan dalam tutorial Basic Electronics .

Satu-satunya hal yang perlu kita ketahui tentang resistor pada saat ini adalah bahwa meskipun mereka secara kasar terlihat sama, mereka semua memiliki nilai yang berbeda. Anda dapat mengetahui seberapa besar resistansi yang ditawarkan masing-masing dengan membaca kode resistor yang ditandai pada mereka. Kode resistor dibaca dari kiri ke kanan ke arah pita emas (atau perak).

Untuk memulai, cara termudah untuk menafsirkan kode adalah dengan menggunakan kalkulator resistor grafis online . Setelah Anda cukup menggunakannya, Anda akan mulai belajar bagaimana menafsirkannya sendiri tanpa kalkulator.

Papan tempat memotong roti sirkuit

Masukkan LED ke papan tempat memotong roti. Hubungkan resistor 150 ohm secara seri dengan katoda LED.

Menggunakan kabel inti hitam solid, sambungkan ujung berlawanan dari resistor (sisi yang tidak terhubung ke LED) ke ground di Arduino.

Menggunakan kabel inti padat merah, sambungkan anoda LED ke pin digital 7 pada Arduino.

Berkedip LED Eksternal

Anda dapat mengedipkan LED eksternal dengan membuka kode contoh Blink dan mengubah kode ini dan mengganti semua angka 13 ke angka 7 setiap kali muncul. Dengan melakukan ini, Anda hanya mengubah pin digital yang dihidupkan dan dimatikan dari 13 menjadi 7 agar sesuai dengan sirkuit yang Anda buat di papan tempat memotong roti Anda.

Setelah Anda menguasai LED yang berkedip dan pudar, Anda dapat mentransfer pengetahuan ini untuk mengendalikan motor. Namun, Anda tidak dapat menghubungkan motor langsung ke pin Arduino karena dua alasan. Pertama, pin Arduino hanya mampu memberikan sedikit arus, dan motor adalah babi saat ini (terutama ketika mulai dan berhenti). Juga, ketika motor berhenti, itu menghasilkan arus polaritas berlawanan dengan yang sedang berjalan. Arus ini diketahui merusak pin Arduino dan menghentikannya agar tidak berfungsi. Dengan demikian, membangun sirkuit buffer berguna.

Yang Anda butuhkan untuk mengendalikan motor menggunakan Arduino adalah resistor 2K, transistor NPN (TIP120 dalam kasus ini), dan dioda 1N4001. 2K resistor berfungsi untuk melindungi pin Arduino, transistor berfungsi sebagai katup yang memungkinkan aliran lebih atau kurang melalui motor. Inilah yang menghidupkan dan mematikan motor, dan mengontrol kecepatannya.

Dioda digunakan sebagai buffer. Ketika listrik mengalir melalui motor, dioda tidak melakukan apa-apa. Namun, ketika motor berhenti, arus balik mengalir melintasi dioda, dan kembali melalui motor. Ini melindungi sirkuit dari lonjakan tegangan mendadak.

Jika semua ini terdengar membingungkan, Anda dapat mempelajari lebih lanjut tentang komponen dasar ini di Kelas Elektronik saya .

Jika Anda ingin menghidupkan dan mematikan motor menggunakan sirkuit dalam gambar, Anda perlu membuat dua koneksi lagi. Pertama, sambungkan arde paket baterai eksternal ke pin arde Arduino. Ini disebut "berbagi tanah" dan diperlukan agar sirkuit berfungsi. Selanjutnya, hubungkan pin 13 dari Arduino ke resistor 2K yang terhubung ke basis transistor. Setelah ini selesai, muat contoh Blink dan unggah ke Arduino. Alih-alih berkedip LED, itu akan menghidupkan dan mematikan motor.

Jika Anda ingin mengontrol kecepatan motor, ubah kabel ke pin 13, dan muat contoh fade untuk menambah dan mengurangi kecepatan motor.

Mungkin sekarang Anda sadar, tak satu pun dari solusi ini akan membalikkan motor. Untuk membuat motor berputar ke belakang, Anda membutuhkan jembatan-H.

H-bridge adalah sirkuit yang memungkinkan arah motor untuk dibalik. Jembatan H yang lebih maju - seperti jenis yang ditemukan di dalam motor servo - juga memungkinkan Anda untuk mengontrol kecepatan motor.

Pada dasarnya, jembatan-H terdiri dari empat sakelar atau transistor. Pada contoh di atas, ada sakelar antara setiap kutub motor dan arde. Ada juga satu set sakelar antara masing-masing kutub motor dan daya.

Ketika sakelar-sakelar ini digambarkan dalam diagram, sakelar-sakelar itu terlihat seperti "H". Begitulah sirkuit mendapatkan nama H-jembatan.

Ketika set sakelar berlabel "A" ditutup, daya mengalir melalui motor sedemikian rupa sehingga berputar searah jarum jam.

Ketika set "B" lainnya ditutup, daya mengalir ke arah yang berlawanan dan motor berputar berlawanan arah jarum jam.

Yang penting untuk diingat ketika berhadapan dengan H-bridges adalah bahwa kedua set tidak dapat ditutup pada saat yang sama, atau power dan ground akan terhubung langsung, dan Anda akan mengalami hubungan pendek.

Selain itu, jika Anda mencampur dan mencocokkan sakelar seperti menutup A1 dan B2, Anda juga akan membuat korsleting. Penting bahwa sakelar “A” tertutup atau sakelar “B”. Tidak pernah keduanya atau kombinasi keduanya.

Jika Anda ingin mengontrol kecepatan, Anda akan menggunakan empat transistor alih-alih sakelar dan mengontrol basis masing-masing transistor menggunakan Arduino Anda.

Di atas adalah contoh kasar dari jembatan-H DIY menggunakan dua transistor PNP (2N3906) dan dua NPN (2N3904). Sebelum Anda keluar dan membangun sirkuit ini dan memasukkannya ke dalam proyek Anda, penting untuk diingat bahwa transistor ini tidak dapat menangani banyak arus sama sekali. Contoh ini hanya boleh dicoba dengan motor yang relatif 'sangat kecil' (tidak lebih besar dari yang digambarkan), dan tidak perlu dibuat. Terutama di sini hanya untuk menjelaskan konsepnya. Kami akan menggunakan papan pengontrol motor dengan jembatan H-pre-made saat kami melanjutkan kursus.

Nah, itu tidak mungkin, mari kita bahas secara singkat tentang apa yang terjadi. Setiap sisi "H" terdiri dari transistor PNP di "atas" dan transistor NPN di "bawah." Basis dari masing-masing transistor ini terhubung ke rel umum melalui resistor 1K (untuk melindungi Arduino), dan rel ini terhubung ke pin Arduino. Emitor dari transistor PNP terhubung ke daya, dan emitor dari transistor NPN terhubung ke ground. Di setiap sisi 'H', kedua kolektor terhubung bersama untuk bergabung dengan pin motor tunggal. Juga termasuk dalam rangkaian adalah empat dioda proteksi silikon 1N4001 yang bias terbalik antara setiap pin motor dan suplai tegangan positif dan ground.

Dengan menggunakan kombinasi transistor PNP dan NPN - berbeda dengan empat transistor NPN - dua hal tercapai. Pertama, ia menciptakan pengaturan di mana satu transistor di setiap sisi selalu terlepas, mencegah celana pendek. Kedua, memungkinkan kontrol jembatan-H hanya dengan dua pin digital dari Arduino.

Misalnya, jika Anda memiliki satu pin Arduino yang mengirim sinyal tinggi ke satu sisi 'H', dan pin Arduino lainnya mengirim sinyal rendah ke sisi lain, listrik akan mengalir dari PNP di satu sisi ke NPN di sisi. lain. Jika Anda membalikkan pin Arduino, listrik kemudian akan mengalir melalui pasangan transistor yang berlawanan, membalikkan arah motor.

Kecepatan motor juga dapat dikontrol menggunakan jembatan-H seperti ini dengan PWM-ing pin Arduino positif daripada mengaturnya ke TINGGI.

Jika Anda terus maju dan membangun sirkuit ini, Anda dapat menggunakan kode berikut untuk melihatnya beraksi:

void setup() {
  // set the digital pins as outputs
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);  
}

void loop() {
  //spin clockwise
  digitalWrite(5, LOW);   
  digitalWrite(6, HIGH);
  delay(2000);

  //spin counterclockwise
  digitalWrite(5, HIGH);    
  digitalWrite(6, LOW);
  delay(2000);              
}

Jika Anda ingin menguji mengendalikan kecepatan di kedua arah, coba PWM-pin dasar transistor dengan kode ini:

void setup() {
  // set the digital pins as outputs
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);  
}

void loop() {
  //spin slowly clockwise
  digitalWrite(5, LOW);   
  analogWrite(6, 80);
  delay(2000);

  //spin faster counterclockwise
  analogWrite(5, 180);    
  digitalWrite(6, LOW);
  delay(2000);              
}

Membangun jembatan-H yang sangat andal adalah bentuk seni tersendiri dan di luar ruang lingkup kelas ini. Sebagai gantinya, kita akan menggunakan pelindung dan modul pengontrol motor. Ini pada dasarnya adalah papan sirkuit dengan jembatan H-pre-made untuk mengendalikan motor.

Beberapa motor bahkan sudah memiliki H-bridge sendiri, karena Anda akan belajar berikutnya dalam pelajaran servo.

Cari Blog Ini

belajar raspi

OTAK ROBOT

Arduino

Tancapkan.

Memprogram Arduino

Catatan Tentang Pemrograman

Sintaksis

Ekspresi Kode

Struktur Program

Jalankan Program

Semua Tentang Breadboards

Catatan Cepat tentang LED

Resistor

Papan tempat memotong roti sirkuit

Berkedip LED Eksternal

Pudar LED

PERTANYAAN KUIS 1

PERTANYAAN KUIS 2

PERTANYAAN KUIS 3

PERTANYAAN KUIS 4

Komentar

Posting Komentar

Postingan populer dari blog ini

Pendahuluan: Otak Robot

Arduino

Tancapkan.

Memprogram Arduino

Catatan Tentang Pemrograman

Sintaksis

Ekspresi Kode

Struktur Program

Jalankan Program

Semua Tentang Breadboards

Catatan Cepat tentang LED

Resistor

Papan tempat memotong roti sirkuit

Berkedip LED Eksternal

Pudar LED

PERTANYAAN KUIS 1

PERTANYAAN KUIS 2

PERTANYAAN KUIS 3

PERTANYAAN KUIS 4

Komentar

Posting Komentar

Postingan populer dari blog ini