SuryaUniv Arduino Muhammad Bangun - Agung 202136575862733 PDF
SuryaUniv Arduino Muhammad Bangun - Agung 202136575862733 PDF
M.BANGUN
AGUNG
ARDUINO FOR BEGINNERS
Kata Pengantar
Menulis buku tidaklah semudah yang dibayangkan. Banyak halangan dan
rintangan selama saya menuliskan buku ini. Buku ini saya tulis sebagai bentuk
kontribusi saya untuk tugas akhir Mata Kuliah Teknologi dan Masyarakat
Program Studi Human Computer Interaction di Surya University.
Sebagai seseorang yang taat akan agamanya, patutlah jika saya terlebih
dahulu mengucapkan puji syukur kepada Tuhan yang Maha Esa. Tanpa rahmat
dan hidayahnya, saya tidak mungkin menyelesaikan buku ini tepat pada
waktunya.
Selama saya menlis buku ini, saya sering mengalami berbagai kesulitan.
Karena itu saya sangat berterima kasih kepada teman-teman saya atas semua
dukungannya. Bagi saya tidak ada yang lebih memotivasi daripada feedback dan
dukungan dari teman-teman saya.
Saya juga ingin mengucapkan terima kasih kepada dosen saya Onno W.
Purbo yang telah memberikan saya tugas ini. Beliau mengharapkan mahasiswanya
dapat sukses seperti beliau.
Dengan ini saya mempersembahkan buku pertama saya. Semoga buku ini
bisa bermanfaat bagi saya dan para pembaca.
i
Daftar Isi
ii
3.8 Kesalahan-kesalahan yang Mungkin Terjadi .................................................. 50
3.9 Latihan ............................................................................................................ 50
4.1 Yang Anda Butuhkan ...................................................................................... 52
4.2 Mempelajari Dasar-dasar dari Kode Morse .................................................... 52
4.3 Membuat Morse Code Generator .................................................................... 53
4.4 Interface Generator.......................................................................................... 55
4.5 Output Simbol Kode Morse ............................................................................ 57
4.6 Memasang dan Menggunakan Class Telegraph .............................................. 59
4.7 Sentuhan Akhir ............................................................................................... 63
4.8 Kesalahan-kesalahan yang Mungkin Terjadi .................................................. 65
4.9 Latihan ............................................................................................................ 65
5.1 Yang Anda Butuhkan ...................................................................................... 69
5.2 Accelerometer ................................................................................................. 69
5.3 Menghidupkan Accelerometer ........................................................................ 70
5.5 Kontroler dan Game ........................................................................................ 76
5.6 Membuat Game Sendiri .................................................................................. 79
6.7 Aplikasi Proyek ............................................................................................... 88
6.8 Kesalahan-kesalahan yang Mungkin Terjadi .................................................. 89
6.9 Latihan ............................................................................................................ 89
6.1 Yang Anda Butuhkan ...................................................................................... 91
6.2 PC Transfer Sensor data ke Internet................................................................ 91
6.3 Mendaftarkan Aplikasi di Twitter ................................................................... 93
6.4 Tweeting Pesan dengan Processing ................................................................ 94
6.5 Berkomunikasi Menggunakan Perisai Ethernet .............................................. 98
6.6 Emailing dari Command Line ....................................................................... 104
6.7 Emailing Langsung dari Arduino .................................................................. 107
6.8 Mendeteksi Gerak Menggunakan Passive Infrared Sensor ........................... 112
6.9 Menyatukan Semuanya ................................................................................. 115
6.10 Kesalahan-kesalahan yang Mungkin Terjadi .............................................. 118
6.11 Latihan ........................................................................................................ 119
Daftar Pustaka ...................................................................................................... cxx
Lampiran ........................................................................................................... cxxii
iii
Pendahuluan
Selamat datang di Arduino dan dunia menarik dari komputasi fisik.
Arduino adalah sebuah proyek open source yang terdiri dari perangkat keras dan
perangkat lunak. Pada awalnya, Arduino diciptakan untuk memberikan desainer
dan seniman platform prototyping untuk kursus desain interaksi. Sekarang para
penggemar Arduino dan para ahli di seluruh dunia menggunakannya untuk
membuat proyek komputasi fisik, dan sekarang Anda juga bisa.
Anda tidak perlu tahu apa-apa tentang teknik elektronika untuk membaca
buku ini. Anda tidak hanya akan belajar bagaimana menggunakan beberapa yang
paling penting elektronik bagian di halaman pertama. Anda juga akan belajar
bagaimana menulis program yang dibutuhkan untuk menjalankan proyek Anda.
Buku ini akan memberikan teori dan praktek dasar-dasar yang Anda
butuhkan untuk membangun proyek-proyek Anda. Di dalam buku ini juga
terdapat proyek-proyek ringan yang dapat Anda kerjakan, dan di setiap bab buku
ini memiliki bagian pemecahan masalah untuk membantu ketika terjadi kesalahan.
Buku ini adalah panduan cepat untuk mulai memberi Anda pengetahuan sampai
dengan memungkinkan Anda untuk segera membuat proyek Anda sendiri.
1
Bab 1
Mengenal Arduino
2
Selamat datang di
Arduino
1.1 Apakah Arduino itu?
Arduino awalnya dibangun untuk desainer dan seniman - orang dengan
keahlian teknis sedikit. Bahkan tanpa pengalaman pemrograman, Arduino
memungkinkan mereka untuk membuat prototipe desain yang canggih dan
beberapa karya seni interaktif yang menakjubkan. Jadi, seharusnya tidak
mengejutkan bahwa langkah pertama dengan Arduino sangat mudah, bahkan lebih
mudah lagi untuk orang-orang dengan latar belakang teknis yang kuat. Akan
tetapi mendapatkan dasar-dasar yang. Anda akan mendapatkan hasil maksimal
bekerja dengan Arduino jika Anda terbiasa dengan papan Arduino sendiri, dengan
perkembangan dari Arduino sendiri, dan dengan teknik seperti komunikasi serial.
Satu hal yang perlu dipahami sebelum memulai komputasi fisik. Jika Anda
telah bekerja dengan komputer sebelumnya, Anda mungkin akan bertanya-tanya,
apakah maksud dari komputasi fisik? Karena komputer sendiri adalah benda fisik
dan menerima input dari keyboard dan mouse. Mereka memberikan output berupa
suara dan video untuk speaker fisik dan menampilkan gambar. Jadi, bukankah
semua komputasi pada komputer adalah komputasi fisik pada akhirnya?
3
Di dalam bab ini Anda akan belajar bagaimana Anda akan memulai
dengan komputasi fisik dengan belajar bagaimana mengontrol Arduino, alat-alat
apa saja yang Anda butuhkan, dan cara menginstal dan mengkonfigurasi mereka.
Kemudian kita akan cepat sampai ke bagian yang menyenangkan; Anda akan
mengembangkan program pertama Anda untuk Arduino.
4
Mereka mungkin berbeda dalam penampilan mereka, tetapi mereka
memiliki banyak kesamaan, dan Anda dapat memprogram mereka semua dengan
alat dan library yang sama. Selain papan resmi, Anda juga dapat menemukan
berbagai tiruan Arduino yang tak terhitung jumlahnya di internet. Semua orang
diperbolehkan untuk menggunakan dan mengubah desain papan asli, dan banyak
orang membuat versi mereka sendiri dari papan Arduino, misalnya Freeduino,
Seeduino, Boarduino, dan Paperduino yang papan sirkuitnya berupa kertas.
Arduino adalah merek dagang terdaftar dan hanya papan resmi yang diberi
nama"Arduino". Tiruan-tiruannya biasanya diakhiri dengan”duino.”Anda dapat
menggunakan setiap tiruan yang sepenuhnya kompatibel dengan Arduino asli
untuk membangun semua proyek di dalam buku ini.
• Sebuah papan Arduino seperti Uno, Duemilanove, atau Diecimila. • Kabel USB
untuk menghubungkan Arduino ke komputer Anda. • Sebuah LED. • IDE Arduino
(akan digunakan di setiap bab).
Pada Gambar 1.2, pada halaman berikutnya, Anda dapat melihat foto dari
papan Arduino Diecimila dan bagian-bagiannya yang paling penting.
5
Pins Digital I/O
Tombol Reset
Konektor USB
Jumper
(khusus untuk
beberapa
jenis Arduino)
Mikrokontroler
Power Plug
6
hanya memberikan 5 volt, dan kadang-kadang Anda membutuhkan lebih banyak
daya.
Dalam situasi ini, solusi terbaik biasanya adalah adaptor AC yang
memberikan tegangan 9V (kisaran yang direkomendasikan adalah 7V untuk 12V).
Anda membutuhkan adaptor dengan ujung laras 2,1 mm dan pusat positif
(tanyakan kepada orang yang menjualnya). Tancapkan ke power plug Arduino,
dan Arduino bisa segera dinyalakan, bahkan ketika tidak terhubung ke komputer.
Dengan cara itu, jika Anda menghubungkan Arduino ke port USB, Arduino akan
menggunakan daya eksternal jika tersedia.
Harap diperhatikan bahwa beberapa versi papan Arduino seperti Arduino-
NG dan Diecimila tidak beralih secara otomatis antara daya eksternal dan pasokan
USB. Mereka dirancang dengan jumper seleksi listrik (lihat gambar 1.2) berlabel
PWR_SEL dan Anda harus mengaturnya secara manual untuk masing-masing
EXT atau USB.
Sekarang Anda telah mengetahui dua cara untuk menyalurkan daya ke
Arduino. Ketika Arduino dihubungkan dengan komputer Anda, Arduino tidak
mengambil semua daya yang ada, namun Arduino juga membagin daya tersebut
dengan perangkat lain. Pada bagian gambar 1.2, pada halaman sebelumnya, Anda
dapat melihat beberapa soket (disebut juga dengan pin, karena internal mereka
terhubung ke pin di mikrokontroler) terkait dengan power supply :
• Menggunakan pin berlabel 3V3 dan 5V, Anda dapat daya perangkat eksternal
terhubung ke Arduino dengan 3,3 volt atau 5 volt.
• Dua pin berlabel Gnd memungkinkan yang perangkat eksternal Anda untuk
berbagi kesamaan dengan Arduino.
• Beberapa proyek bersifat portabel, sehingga mereka akan menggunakan pasokan
listrik portabel seperti baterai. Anda menghubungkan sumber daya eksternal
seperti baterai ke Vin dan Gnd soket. Jika Anda menghubungkan adaptor AC ke
colokan (soket) listrik Arduino, Anda dapat menyalurkan tegangan dari adaptor
melalui pin ini.
Pada bagian kanan bawah papan, ada enam pin input analog A0 - A5.
Anda dapat menggunakannya untuk menghubungkan sensor analog ke Arduino.
7
Mereka mengambil data sensor dan mengubahnya menjadi angka antara 0 dan
1023. Di bagian atas papan ada 14 pin digital IO bernama D0 - D13. tergantung
kepada kebutuhan Anda,
Anda dapat menggunakan pin-pin untuk input atau output digtal, sehingga
Anda dapat menghidupkan dan mematikan LED. Pin-pin tersebut (D3, D5, D6,
D9, D10, dan D11) juga dapat bertindak sebagai input/output analog. Dalam mode
ini, mereka mengkonversi dari 0 sampai 255 angka digital menjadi tegangan
analog. Semua pin ini dihubungkan ke mikrokontroler. Mikrokontroler
menggabungkan CPU dengan beberapa fungsi periferal seperti saluran I/O. Ada
banyak jenis mikrokontroler yang tersedia, tetapi biasanya Arduino dilengkapi
dengan ATmega328 atau ATmega168. Keduanya adalah mikrokontroler 8-bit
yang diproduksi oleh sebuah perusahaan bernama Atmel.
Meskipun komputer modern memuat program dari hard drive,
mikrokontroler biasanya harus diprogram terlebih dahulu. Itu berarti Anda harus
memuat perangkat lunak Anda ke mikrokontroler melalui kabel. Anda hanya
perlu mengunggahnya ke dalam mikrokontroler sekali saja. Program tersebut akan
tetap berada di dalam mikrokontroler sampai mendapat program baru.
Setiap kali Anda memberikan suplai listrik ke Arduino, program byang
ada dalam mikro kontroler akan disimpan dalam mikrokontroler dan dijalankan
secara otomatis. Jika Anda menekan tombol reset pada Arduino, semuanya akan
reinitialized. Program yang telah disimpan tidak akan hilang, namun berjalan dari
awal.
8
Instalasi Arduino IDE pada Windows
Arduino IDE berjalan pada semua versi terbaru dari Microsoft Windows,
seperti Windows XP, Windows Vista, dan Windows 7, dan Windows 8. Instalasi
IDE untuk Windows sangat mudah, karena IDE Arduino untuk Windows diunduh
sebagai arsip ZIP mandiri, sehingga Anda tidak memerlukan sebuah installer.
Unduh arsip, dan ekstrak ke lokasi pilihan Anda.
Sebelum Anda pertama kali menjalankan IDE, Anda harus menginstal
driver untuk Arduino Port USB. Proses ini tergantung pada papan Arduino Anda
dan versi Windows yang digunakan, tetapi Anda selalu harus memasang Arduino
ke port USB pertama untuk memulai proses instalasi driver.
Pada Windows Vista, instalasi driver biasanya terjadi secara otomatis.
Windows XP dan Windows 7 tidak dapat memperbarui/mengupdate dari situs
Arduino secara otomatis. Cepat atau lambat wizard hardware akan meminta Anda
untuk menyambungkan ke path ke driver yang tepat setelah Anda telah diberitahu
untuk melewati instalasi driver otomatis dari Internet. Tergantung dari papan
Arduino Anda, Anda harus menunjuk ke lokasi/direktori yang telah di instalasi
Arduino.
Untuk Arduino Uno dan Arduino mega 2560, pilih Arduino UNO.inf di
direktori driver. Untuk papan yang lebih tua seperti Duemilanove, Diecimila, atau
Nano, pilih driver / FTDI direktori Driver USB. Setelah driver terinstal, Anda
dapat memulai Arduino executable dari direktori utama dengan mengklik dua
kali. Ikuti petunjuk yang diberikan untuk menginstal IDE. Perlu diketahui bahwa
driver USB tidak berubah sesering Arduino IDE. Setiap kali Anda menginstal
versi baru dari IDE, periksa apakah Anda perlu menginstal driver baru juga.
Arduino IDE tersedia sebagai disk image untuk Mac terbaru OS X.9.
Download IDE, klik dua kali, dan kemudian tarik ikon ke folder aplikasi Arduino
Anda. Jika Anda menggunakan Arduino Uno atau Arduino mega 2560, Anda
dapat langsung menjalankan IDE. Sebelum Anda dapat menggunakan IDE dengan
9
yang Arduino lebih tua seperti Duemilanove, Diecimila, atau Nano, Anda harus
menginstal driver untuk port serial Arduino itu. Double klik file
FTDIUSBSerialDriver_10_4_10_5_10_6.pkg untuk platform Anda, dan ikuti
petunjuk instalasi. Ketika menginstal versi baru dari Arduino IDE, Anda biasanya
tidak perlu menginstal driver FTDI lagi (hanya jika ada versi yang lebih baru).
Jika Anda telah menggunakan IDE seperti Eclipse, Xcode, atau Microsoft
Visual Studio sebelumnya, maka Arduino IDE lebih sederhana. Arduino IDE
terdiri dari editor, compiler, loader, dan monitor serial (lihat Gambar 1.3).
10
Gambar 1.3. Tampilan Arduino IDE.
IDE dari Arduino tidak memiliki fitur-fitur canggih seperti debugger atau
code completion. Anda hanya dapat mengubah beberapa preferensi, dan sebagai
aplikasi Java itu tidak sepenuhnya mengintegrasikan ke desktop Mac. Ini masih
digunakan, meskipun, dan bahkan memiliki dukungan yang layak untuk
manajemen proyek.
Pada Gambar 1.4, Anda dapat melihat toolbar IDE yang memberikan
akses instan ke fungsi-fungsi yang penting :
• Dengan tombol Verify, anda dapat mengkompilasi program yang saat ini di
editor.
• Tombol New menciptakan program baru dengan mengosongkan isi dari jendela
editor saat ini. Sebelum hal itu terjadi, IDE memberikan Anda kesempatan untuk
menyimpan semua perubahan yang belum disimpan.
• Dengan Open, Anda dapat membuka program yang ada dari sistem file.
• Tombol Save menyimpan program saat ini.
• Ketika Anda mengklik tombol Upload, IDE mengkompilasi saat ini Program dan
upload ke papan Arduino yang telah Anda pilih di IDE menu Tools> Serial Port.
•Arduino dapat berkomunikasi dengan komputer melalui koneksi serial. Mengklik
tombol Serial Monitor membuka jendela Serial Monitor yang memungkinkan
Anda untuk melihat data yang dikirim oleh Arduino dan juga untuk mengirim data
kembali.
• Tombol Stop menghentikan Serial Monitor.
12
Mari kita lihat bagaimana program ini bekerja. Dalam dua baris pertama
kita mendefinisikan dua konstanta int menggunakan const. LED_PIN mengacu
pada jumlah IO pin digital yang digunakan, dan PAUSE mendefinisikan jumlah
waktu yang diperlukan setiap LED berkedip dalam milidetik.
Setiap program Arduino membutuhkan fungsi bernama setup(). Sebuah
definisi fungsi selalu mematuhi skema berikut :
Nilai <return data> <function name ' (' <list dari parameters> ') '
Dalam kasus ini, nama fungsinya adalah setup (), dan jenis nilai
kembalinya kosong membatalkan : ia tidak mengembalikan apa-apa. setup() tidak
mengharapkan adanya argumen, jadi parameternya juga kosong. Sebelum kita
membahas program tersebut lebih jauh, Anda perlu mengetahui tipe-tipe data
yang terdapat pada Arduino.
Setiap bagian dari data yang Anda simpan dalam program Arduino
memiliki tipe datanya masing-masing.
Tergantung pada kebutuhan Anda, Anda dapat memilih dari tipe-tipe data berikut
ini :
• Tipe data boolean mengambil satu byte memori dan dapat bernilai benar atau
salah.
• Tipe data char mengambil satu byte nomor memori dan menyimpan dari -128
sampai 127. Angka-angka ini biasanya mewakili karakter yang dikodekan dalam
ASCII.
13
• Tipe data int (integer) membutuhkan dua byte memori, Anda dapat
menggunakannya untuk menyimpan angka dari -32.768 ke 32.767. Unsigned int
juga menghabiskan dua byte memori tetapi menyimpan angka dari 0 sampai
65.535.
• Untuk angka yang lebih besar, gunakan tipe data long. Mengkonsumsi empat
byte memori dan menyimpan nilai dari -2147483648 ke 2147483647. Unsigned
long juga perlu empat byte tetapi menyimpan rentang nilai dari 0 sampai
4,294,967,295.
• Tipe data float dan double adalah tipe data yang sama. Anda dapat
menggunakan jenis tipe data ini untuk menyimpan angka floating-point.
Keduanya menggunakan empat byte memori dan mampu menyimpan nilai-nilai
dari-3.4028235E +38 untuk 3.4028235E +38. • Tipe data void hanya untuk
deklarasi fungsi. Ini menunjukkan bahwa fungsi tersebut tidak mengembalikan
nilai.
Dari contoh di atas, nilai-nilai array dan more_values mengandung elemen yang
sama. Ada dua cara yang berbeda untuk menginisialisasi array. Perhatikan bahwa
indeks array dimulai dari 0, dan perlu diingat pula bahwa elemen array yang telah
terinisialisasi mengandung nilai random.
14
• Sebuah string adalah sebuah array nilai char. Arduino IDE mendukung
penciptaan string dengan beberapa sintaksis gula-semua ini deklarasi membuat
string dengan isi yang sama.
15
Arduino mudah, karena dicetak di papan tulis. Jenis populer adalah Uno,
Duemilanove, Diecimila, Nano, Mega Mini, NG, BT, LilyPad, Pro, atau Pro Mini.
Dalam beberapa kasus, Anda juga harus memeriksa apa mikrokontroler Arduino
Anda menggunakan paling memiliki ATmega168 atau sebuah ATmega328. Anda
dapat menemukan jenis mikrokontroler dicetak pada mikrokontroler itu sendiri.
Ketika Anda telah mengidentifikasi dengan tepat jenis Anda Arduino,
memilih dari menu Tools> Board. Sekarang Anda harus memilih port serial
Arduino Anda terhubung untuk dari > menu Serial Port Tools. Pada Mac OS X,
nama port serial dimulai dengan / dev / cu.usbserial atau / dev / cu.usbmodem.
Pada sistem Linux, itu harus / dev/ttyUSB0, / dev/ttyUSB1, atau sesuatu yang
serupa tergantung pada jumlah port USB komputer Anda. Pada sistem Windows,
itu sedikit lebih rumit untuk mengetahui kanan port serial, tapi masih tidak sulit.
Pergi ke Device Manager, dan mencari USB Serial Port di bawah Ports (COM &
LPT) entri menu.
Biasanya port bernama COM1, COM2, atau sesuatu yang serupa. Setelah
Anda telah memilih port serial kanan, klik tombol Verify, dan Anda akan melihat
output berikut di daerah pesan IDE (yang Arduino IDE menyebut program sketsa)
: Binary ukuran sketsa : 1010 bytes (dari 32256 byte maksimum) Ini berarti IDE
berhasil telah menyusun kode sumber ke dalam 1.010 byte kode mesin yang kita
dapat meng-upload ke Arduino.
Jika Anda melihat pesan kesalahan sebagai gantinya, periksa apakah Anda
telah mengetik di Program benar. Tergantung pada papan Arduino yang Anda
gunakan, maksimum byte mungkin berbeda. Misalnya pada Arduino
Duemilanove, biasanya 14336 byte.
Sekarang klik tombol Upload, dan setelah beberapa detik, Anda akan
melihat output berikut di bagian isi pesan :
Binary ukuran sketsa : 1010 bytes (dari 32256 byte maksimum) Ini adalah persis
pesan yang sama kita mendapat setelah kompilasi program, dan itu memberitahu
kita bahwa 1.010 byte kode mesin dipindahkan berhasil ke Arduino. Dalam kasus
kesalahan, memeriksa apakah Anda memilih jenis Arduino benar dan port serial
yang benar dalam Menu Tools.
16
Selama proses upload, TX dan RX LED akan berkedip selama beberapa
detik. Ini adalah normal, dan itu terjadi setiap kali Arduino dan komputer Anda
berkomunikasi melalui port serial. Ketika Arduino mengirimkan informasi,
ternyata pada TX LED. Ketika mendapat beberapa bit, ternyata pada RX LED.
Karena komunikasi ini cukup cepat, LED mulai berkedip, dan Anda tidak dapat
mengidentifikasi transmisi byte tunggal (jika Anda bisa, Anda mungkin alien).
Menyusun dan meng-upload PROGRAM 40 sementara program ini
berjalan. Pin dimulai dalam keadaan LOW dan tidak arus keluaran apapun. Kita
mengaturnya agar TINGGI dalam perangkat lunak menggunakan digitalWrite ()
dan biarkan keluaran 5 volt untuk 500 milidetik. Akhirnya, kita mengatur kembali
ke LOW untuk 500 milidetik dan ulangi seluruh proses. Diakui, LED statusnya
tidak terlihat sangat spektakuler. Jadi, dalam bagian berikutnya, kita akan
melampirkan”nyata”LED ke Arduino.
1.7 LED
LED yang datang dengan Arduino bagus untuk tujuan pengujian, tapi
Anda tidak harus menggunakan mereka dalam proyek-proyek elektronik Anda
sendiri.
Mereka semua memiliki arti khusus, dan itu adalah gaya buruk untuk
menggunakannya dalam konteks yang berbeda. Juga, mereka sangat kecil dan
tidak sangat terang, jadi itu adalah ide yang baik untuk mendapatkan beberapa
LED dan tambahan belajar bagaimana untuk menghubungkan mereka ke Arduino.
Ini sangat mudah. Kita tidak akan menggunakan jenis yang sama dari LED yang
dipasang di Arduino papan. Mereka adalah perangkat permukaan - mount (SMD)
yang sulit untuk menangani. Anda jarang akan bekerja dengan bagian-bagian
SMD, karena bagi sebagian besar dari mereka Anda membutuhkan peralatan
khusus dan banyak pengalaman. Mereka menghemat biaya segera setelah Anda
mulai produksi massal dari perangkat elektronik, tetapi murni penggemar tidak
akan membutuhkan mereka sering. LED yang kita butuhkan adalah melalui
17
lubang bagian, Anda dapat melihat beberapa di mengapa mereka biasanya
memiliki satu atau lebih kabel panjang.
Pertama Anda menempatkan kabel melalui lubang di papan sirkuit cetak.
Maka Anda biasanya membungkuk, solder, dan memotong mereka untuk
melampirkan bagian ke papan tulis. Bila tersedia, Anda juga dapat plug mereka ke
soket seperti yang kita miliki pada Arduino atau pada breadboards. Pasang
konektor pendek dari LED ke tanah pin (GND) dan satu lagi ke pin 13. Anda
dapat melakukannya saat berkedip sketsa masih berjalan. Kedua LED status dan
LED eksternal akan mulai berkedip. Benar-benar memastikan bahwa Anda
menggunakan pin 13! Jika Anda menghubungkan LED untuk setiap pin lain,
mungkin akan hancur.
Alasannya adalah pin yang 13 memiliki resistor internal yang pin lainnya
tidak memiliki. Anda baru saja menambahkan bagian elektronik eksternal pertama
Anda untuk Anda Arduino, dan Anda telah membuat proyek komputasi fisik
pertama Anda. Anda telah menulis beberapa kode, dan itu membuat dunia sedikit
lebih cerah. anda versi digital sendiri dari”fiat lux”13 Anda akan membutuhkan
teori dan keterampilan yang telah Anda pelajari dalam bab ini untuk hampir setiap
proyek Arduino.
Dalam bab berikutnya, Anda akan melihat bagaimana mendapatkan
kontrol lebih besar atas LED, dan Anda akan belajar bagaimana untuk
mendapatkan keuntungan dari lebih fitur canggih dari Arduino IDE.
Jangan panik! Jika tidak bekerja, Anda mungkin telah mepasang LED
dengan cara yang salah. Ketika perakitan proyek elektronik, bagian jatuh ke dalam
dua kategori : mereka yang Anda dapat me-mount cara apapun yang Anda suka
dan mereka yang membutuhkan arah khusus. Sebuah LED memiliki dua konektor
: anoda (positif) dan katoda (negatif). Sangat mudah untuk campuran mereka, dan
ilmu saya guru mengajarkan saya mnemonic berikut : katoda adalah necative.
18
sekarang juga mudah untuk mengingat apa konektor negatif dari LED adalah : itu
adalah pendek, dikurangi, kurang dari.
Jika Anda adalah orang yang lebih positif, kemudian berpikir dari anoda
sebagai besar ditambah lagi. Anda alternatif dapat mengidentifikasi Konektor
menggunakan kasusnya LED. Di sisi negatif kasus ini datar, sementara itu bundar
di sisi positif. Memilih port serial yang salah atau tipe Arduino juga merupakan
kesalahan umum. Jika Anda mendapatkan pesan error seperti”Serial port sudah
digunakan”ketika meng-upload sketsa, periksa apakah Anda telah memilih hak
port serial dari menu Tools> Serial Port. Jika Anda mendapatkan pesan
seperti”upload error”atau”program did not respond,”periksa apakah Anda telah
memilih yang tepat Arduino papan dari Menu Tools> Board.
Program Arduino Anda, seperti semua program, akan mengandung bug.
Typos dan kesalahan sintaks akan terdeteksi oleh kompilator. Pada Gambar 1.13,
sebagai berikut halaman, Anda dapat melihat pesan error yang khas. Alih-alih
pinMode (), kita disebut pinMod (), dan karena compiler tidak menemukan fungsi
memiliki nama itu, berhenti dengan pesan error. Arduino IDE menyoroti garis,
menunjukkan kesalahan dengan latar belakang kuning, dan mencetak pesan
kesalahan membantu.
Bug lain mungkin lebih halus dan kadang-kadang Anda harus hati-hati
mempelajari kode Anda dan menggunakan beberapa teknik debugging. Mungkin
saja, walaupun jarang, Anda menggunakan LED yang rusak. Jika tidak ada trik
yang disebutkan membantu, cobalah LED lain.
1.9 Latihan
• Cobalah pola blink yang berbeda menggunakan lebih jeda dan bervariasi jeda
panjang (mereka tidak perlu harus semua sama). Juga, percobaan dengan jeda
yang sangat singkat yang membuat LED berkedip pada tinggi frekuensi. Dapatkah
Anda menjelaskan efek Anda mengamati ?
• Biarkan output nama Anda LED dalam kode Morse.
19
Bagian Dalam Arduino
Untuk aplikasi sederhana, semua yang Anda telah belajar tentang Arduino
IDE di bab sebelumnya sudah cukup. Tapi segera proyek Anda akan mendapatkan
lebih banyak ambisius, dan kemudian akan berguna untuk membagi mereka
menjadi terpisah file yang dapat Anda mengelola secara keseluruhan. Jadi dalam
bab ini, Anda akan belajar bagaimana untuk tetap dalam kontrol atas proyek-
proyek besar dengan Arduino IDE.
Untuk membuat hal-hal yang lebih nyata, Anda akan belajar bagaimana
untuk mengubah komputer Anda menjadi tombol lampu sangat mahal yang
memungkinkan Anda mengontrol LED menggunakan Keyboard.
Untuk mencoba contoh bab ini, Anda hanya perlu beberapa hal :
• Sebuah terminal serial software seperti Putty (untuk pengguna Windows) atau
layar untuk Linux dan Mac OS X pengguna (opsional)
20
2.2 Mengelola Proyek dan Sketsa
Pengembang perangkat lunak modern dapat memilih dari berbagai
pengembangan alat-alat yang mengotomatisasi tugas yang berulang dan
membosankan. Itu juga berlaku untuk embedded system seperti Arduino. Anda
dapat menggunakan pengembangan terpadu lingkungan (IDE) untuk mengelola
program Anda, juga. yang paling salah satu yang populer telah dibuat oleh tim
Arduino. Arduino IDE mengelola semua file milik proyek Anda. Hal ini juga
memberikan akses mudah ke semua alat yang Anda butuhkan untuk menciptakan
binari yang akan berjalan di papan Arduino Anda. Mudah, ia melakukannya diam-
diam.
Seperti yang sudah bisa anda duga sudah dari nama-nama item menu,
Arduino IDE panggilan proyek sketsa. Jika Anda tidak memilih nama, itu
memberi mereka nama yang dimulai dengan sketch_. Anda dapat mengubah nama
setiap kali Anda suka menggunakan perintah Save As. Jika Anda tidak
menyimpan sketsa eksplisit, toko IDE dalam sebuah folder yang telah ditetapkan
Anda dapat melihat.
21
Sketsa Folder item menu. IDE menggunakan direktori tidak hanya untuk
mengatur proyek.
• Folder contoh berisi sketsa sampel yang dapat Anda gunakan sebagai dasar
untuk percobaan Anda sendiri. Dapatkan kepada mereka melalui File > Buka
kotak dialog. Luangkan waktu untuk menelusuri melalui mereka, bahkan jika
Anda tidak mengerti apa pun yang Anda lihat sekarang.
• Direktori library berisi library untuk berbagai tujuan dan perangkat. Setiap kali
Anda menggunakan sensor baru, misalnya, kemungkinan baik bahwa Anda harus
menyalin library pendukung ke folder ini.
Arduino IDE membuat hidup Anda lebih mudah dengan memilih default
wajar untuk banyak pengaturan. Tetapi juga memungkinkan Anda untuk
mengubah sebagian besar pengaturan, dan Anda akan melihat bagaimana pada
bagian berikutnya.
22
Arduino IDE, mari kita melakukan beberapa program. Kita akan membuat
Arduino berbicara dengan dunia luar.
Meskipun standar untuk komunikasi serial telah berubah selama beberapa tahun
terakhir (misalnya, kita menggunakan USB hari ini, dan komputer kita tidak lagi
memiliki konektor RS232), prinsip kerja dasar tetap sama. Dalam kasus yang
paling sederhana, kita dapat menghubungkan dua perangkat hanya menggunakan
tiga kabel : landasan bersama, jalur untuk transmisi data (TX), dan satu untuk
menerima data (RX). Perangkat # 1 GND TX RX Perangkat # 2 GND TX RX
Serial komunikasi mungkin terdengar sedikit old-school, tapi itu masih disukai
jalan bagi perangkat keras untuk berkomunikasi. Sebagai contoh, S di USB adalah
singkatan dari”serial”- dan kapan terakhir kali Anda melihat port paralel ?
(Mungkin ini adalah saat yang tepat untuk membersihkan garasi dan membuang
bahwa PC lama yang Anda ingin berubah menjadi media center suatu hari
nanti....) Untuk meng-upload software, Arduino memiliki port serial, dan kita
dapat menggunakannya untuk menghubungkan Arduino ke perangkat lain, juga
(dalam Bagian 1.6, Kompilasi Program Uploading, pada halaman 38, Anda
belajar bagaimana untuk mencari port serial Arduino Anda terhubung ke). Pada
bagian ini, kita akan menggunakan untuk mengontrol status LED Arduino yang
menggunakan keyboard komputer kita. itu LED harus diaktifkan ketika Anda
23
menekan 1, dan itu harus berubah off ketika Anda menekan 2. Berikut semua
kode yang kita butuhkan :
24
yang kita butuhkan untuk mengirim dan menerima data melalui port serial di kita
Program.
Mari kita membaca dan menafsirkan data. Loop () fungsi dimulai dengan
memanggil Metode yang tersedia Serial ini () di baris 10. tersedia ()
mengembalikan jumlah byte menunggu di port serial. Jika data yang tersedia, kita
membacanya menggunakan Serial.read (). read () mengembalikan byte pertama
data yang masuk jika data tersedia dan -1 sebaliknya.
Jika byte kita telah membaca mewakili karakter 1, kita beralih pada LED
dan mengirim kembali pesan”LED pada”melalui port serial. Kita menggunakan
Serial.println (), yang menambahkan karakter carriage return (kode ASCII 13)
diikuti oleh baris baru (kode ASCII 10) ke teks. Jika kita menerima karakter 2,
kita matikan LED.
Jika kita menerima perintah yang tidak didukung, kita mengirim kembali
pesan yang sesuai dan perintah kita tidak mengerti. Serial.print () bekerja sama
persis seperti Serial.println (), tetapi tidak menambahkan carriage return dan
karakter newline pesan tersebut. Mari kita lihat bagaimana program itu bekerja
dalam prakteknya.
25
Itulah perilaku default Serial ini print () metode, dan Anda dapat mengubah
dengan melewati format specifier untuk fungsi panggilan Anda. Untuk melihat
efek, ganti baris 20 dengan pernyataan berikut:
Serial.println(command, DEC);
Serial.println(command, HEX);
Serial.println(command, OCT);
Serial.println(command, BIN);
Serial.println(command, BYTE);
Unknown command: 65
41
101
1000001
A
26
angka desimal 4711 dapat direpresentasikan dalam oktal dan heksadesimal
sebagai berikut : • 1 × 84 + 1 × 83 + 1 × 82 + 4 × 81 + 7 × 80 = 011147 • 1 × 163
+ 2 × 162 + 6 × 161 + 7 × 160 = 0x1267 Dalam program Arduino, Anda dapat
menentukan literal untuk semua penomoran ini sistem : int desimal = 4711 ; int
biner = B1001001100111 ; int oktal = 011147 ; int heksadesimal = 0x1267 ;
Bilangan biner dimulai dengan karakter B, nomor oktal dengan 0, dan angka
heksadesimal mulai dengan 0x.
Untuk keluar dari perintah layar, tekan Ctrl -a diikuti dengan Ctrl - k. Kita
sekarang dapat berkomunikasi dengan Arduino, dan ini memiliki implikasi besar :
apa pun yang dikendalikan oleh Arduino juga dapat dikontrol oleh komputer
Anda, dan sebaliknya. Switching LED on dan off tidak terlalu spektakuler, tapi
27
coba bayangkan apa yang mungkin sekarang. Anda bisa menggerakkan robot,
mengotomatisasi rumah Anda, atau membuat permainan interaktif. Berikut adalah
beberapa fakta yang lebih penting tentang komunikasi serial :
• Serial Arduino yang menerima buffer dapat menyimpan hingga 128 byte. kapan
mengirimkan sejumlah besar data pada kecepatan tinggi, Anda harus melakukan
sinkronisasi pengirim dan penerima untuk mencegah kehilangan data. Biasanya,
penerima mengirimkan pemberitahuan kepada pengirim setiap kali itu siap untuk
mengkonsumsi sepotong baru data.
28
2.5 Kesalahan-kesalahan yang Mungkin Terjadi
Jika Anda masih mengalami masalah, mungkin karena beberapa masalah
dengan komunikasi serial. Sebagai contoh, Anda mungkin telah mengatur baud
yang salah tingkat.
Pastikan bahwa baud rate yang telah ditetapkan dalam ajakan Anda untuk
Serial.begin () sesuai dengan baud rate pada monitor serial.
2.6 Latihan
• Cobalah untuk membuat perintah lebih mudah dibaca. Misalnya ketika di atas
Anda menuliskan 1, gantilah dengan on, dan ketika Anda menuliskan 2, gantilah
dengan off off.
29
30
Bab 2
Proyek-proyek
Arduino
31
Membuat Arduino
Binary Dice
Hal yang benar-benar akan mulai mendapatkan menarik sekarang bahwa
Anda telah belajar dasar-dasar pengembangan Arduino. Anda sekarang memiliki
kemampuan untuk membuat Anda kompleks pertama, proyek yang berdiri sendiri.
Setelah Anda telah bekerja melalui ini bab, Anda akan tahu bagaimana bekerja
dengan LED, tombol, breadboards, dan resistor. Menggabungkan bagian ini
dengan Arduino memberi Anda hampir kesempatan tak terbatas untuk proyek-
proyek baru dan keren. Proyek pertama kita akan membuat mati elektronik.
Sementara dadu biasa menampilkan hasil mereka menggunakan 1-6 titik, kita
akan menggunakan LED sebagai gantinya.
Untuk percobaan pertama kita, sebuah LED tunggal telah cukup, tetapi
untuk dadu kita membutuhkan lebih dari satu. Anda perlu untuk menghubungkan
beberapa eksternal LED untuk Arduino. Karena Anda tidak dapat melampirkan
mereka semua langsung ke Arduino, Anda akan belajar bagaimana bekerja dengan
breadboards. Juga, Anda perlu tombol yang gulungan dadu, sehingga Anda akan
belajar bagaimana bekerja dengan pushbuttons, juga. Untuk menghubungkan
tombol tekan dan LED untuk Arduino, Anda perlu penting lainnya elektronik
bagian : resistor. Jadi, pada akhir bab, Anda akan memiliki banyak alat-alat baru
dalam kotak peralatan Anda.
32
4. Tiga 1k resistor
5. Dua pushbuttons
6. Beberapa kabel
7. Sebuah papan Arduino seperti Uno, Duemilanove, atau Diecimila
8. Sebuah kabel USB untuk menghubungkan Arduino ke komputer Anda
9. Sebuah sensor kemiringan (opsional) Foto melakukan tidak menunjukkan
bagian standar seperti papan Arduino atau kabel USB.
3.2 Breadboards
33
bagian atau kawat. Itu saja tidak akan menjadi masalah besar, tapi soket yang
terhubung dalam cara khusus.
Sebagian besar soket yang terhubung dalam kolom. Jika salah satu socket
kolom tersambung ke power supply, maka secara otomatis semua soket lain dalam
kolom ini yang didukung juga. Pada papan yang lebih besar di foto, Anda juga
dapat melihat empat baris soket terhubung. ini nyaman untuk sirkuit yang lebih
besar. Biasanya, Anda menghubungkan satu baris untuk Anda power supply dan
satu ke tanah. Dengan cara ini, Anda dapat mendistribusikan kekuasaan dan tanah
untuk setiap titik di papan tulis. Sekarang mari kita lihat bagaimana untuk
menempatkan bagian pada papan tempat breadboard.
34
breadboard. Pastikan bahwa Anda masih dapat mengidentifikasi negatif dan
konektor positif setelah Anda telah memperpendek mereka. Mempersingkat
negatif satu sedikit lebih, misalnya. Juga memakai kacamata keselamatan untuk
melindungi Anda mata ketika memotong konektor!
Hal-hal yang telah kita lakukan sampai sekarang telah langsung. Artinya,
pada prinsipnya kita hanya menambah ground pin Arduino dan yang IO pin
nomor 12. Mengapa kita harus menambahkan resistor, dan apa yang merupakan
resistor ? Sebuah resistor membatasi jumlah arus yang mengalir melalui koneksi
listrik. Dalam kasus kita, melindungi LED dari mengkonsumsi terlalu banyak
kekuatan, karena hal ini akan menghancurkan LED. Anda selalu harus
menggunakan resistor ketika powering sebuah LED! Pada Bagian A.1, Current,
usia Volt, dan Resistance, di halaman 237, Anda dapat mempelajari lebih lanjut
tentang resistor dan band warna mereka.
Anda dapat menggunakan kedua sisi papan breadboard.
Anda tentu akrab dengan dadu biasa menampilkan hasil dalam kisaran dari
satu sampai enam. Untuk meniru dadu tersebut persis dengan perangkat
elektronik, Anda akan membutuhkan tujuh LED dan beberapa logika bisnis yang
cukup rumit. Kita akan mengambil jalan pintas dan menampilkan hasil dari roll
mati dalam biner. Untuk mati biner, kita hanya perlu tiga LED yang mewakili saat
ini hasil. Kita mengubah hasilnya menjadi bilangan biner, dan untuk setiap bit
yang mengatur, kita akan menerangi yang sesuai yang LED. Berikut ini
menunjukkan diagram bagaimana hasil die dipetakan ke LED (segitiga hitam
berdiri untuk bersinar LED). Kita sudah tahu bagaimana mengendalikan LED
tunggal pada papan tempat breadboard. mengontrol tiga LED mirip dan hanya
membutuhkan lebih banyak kabel, LED, 1k resistor, dan pin.
Perbedaan yang paling penting adalah kesamaan. Bila Anda membutuhkan
tanah untuk LED tunggal, Anda dapat menghubungkannya ke LED secara
35
langsung. tapi kita perlu tanah untuk tiga LED sekarang, jadi kita akan
menggunakan baris papan tempat breadboard itu untuk pertama kalinya.
Hubungkan baris ditandai dengan tanda hubung (-) untuk Arduino ground
pin, dan semua soket berturut-turut ini akan bekerja sebagai tanah pin, juga.
Kemudian Anda dapat menghubungkan soket ini baris untuk LED menggunakan
kabel pendek. Segala sesuatu yang lain di sirkuit ini harus tampak akrab, karena
kita hanya memiliki untuk mengkloning sirkuit LED dasar dari bagian
sebelumnya tiga kali.
Perhatikan bahwa kita telah menghubungkan tiga sirkuit ke pin 10, 11, dan
12. Satu-satunya hal yang hilang adalah beberapa perangkat lunak :
36
-}
Ini semua kode yang kita perlu untuk mengimplementasikan versi pertama
dari biner dadu. Seperti biasa, kita mendefinisikan beberapa konstanta untuk pin
output LED terhubung ke. Dalam setup () fungsi, kita mengatur semua pin ke
OUTPUT modus. Untuk dadu, kita perlu angka acak dalam kisaran antara satu
dan enam. Acak () mengembalikan fungsi bilangan acak dalam tertentu berkisar
menggunakan generator nomor pseudorandom. Sejalan 10, kita menginisialisasi
generator dengan beberapa kebisingan kita membaca dari input analog pin A0
(lihat sidebar pada halaman berikutnya untuk mempelajari mengapa kita harus
melakukan itu). Anda mungkin bertanya-tanya di mana A0 konstan dari. Sejak
versi 19, Arduino IDE mendefinisikan konstanta untuk semua pin analog bernama
A0, A1, dan sebagainya.
Kemudian kita benar-benar menghasilkan nomor acak baru antara satu dan
enam dan output dengan menggunakan output_result () function. (tujuh di panggil
untuk random () sudah benar, karena mengharapkan batas atas ditambah satu).
Fungsi output_result () mengambil nomor dan output tiga yang lebih rendah bit
dengan beralih atau menonaktifkan tiga LED kita sesuai. Di sini kita
menggunakan & Operator dan literal biner. The & operator mengambil dua angka
dan menggabungkan mereka bitwise. Ketika dua bit yang sesuai adalah 1,
hasilnya dari operator & adalah 1, juga. Jika tidak, itu adalah 0. The B prefix
memungkinkan Anda untuk menempatkan bilangan biner langsung ke kode
sumber Anda. Sebagai contoh, B11 adalah sama dengan 3. Anda mungkin telah
memperhatikan bahwa loop () fungsi itu dibiarkan kosong, dan Anda mungkin
bertanya-tanya bagaimana dadu tersebut bekerja. Ini cukup sederhana : setiap kali
Anda me-restart Arduino, itu output nomor baru, dan untuk melempar dadu lagi,
Anda harus menekan tombol reset.
37
dapat membangun, dan untuk prototipe pertama, ini adalah OK. Tetapi sering
Anda membutuhkan lebih dari satu tombol, dan juga lebih elegan untuk
menambahkan tombol Anda sendiri anyway. Jadi, itulah yang akan kita lakukan
pada bagian berikutnya.
Pada bagian ini, kita akan menambahkan tombol tekan kita sendiri untuk
dadu biner kita, sehingga kita tidak lagi harus penyalahgunaan tombol reset
Arduino untuk melempar dadu. Kita akan memulai dari yang kecil dan
membangun sebuah sirkuit yang menggunakan tombol tekan untuk mengontrol
LED tunggal. Jadi, apa sebenarnya tombol tekan (pushbuttons)?
Berikut adalah tiga pandangan khas tombol tekan yang dapat digunakan
sebagai tombol reset Arduino itu. Terhubung Terhubung Top Front Side Ia
memiliki empat konektor yang sangat pas pada papan tempat breadboard
(setidaknya setelah Anda telah meluruskan mereka dengan tang). Dua berlawanan
pin terhubung saat tombol ditekan, jika tidak, mereka terputus. Pada Hubungkan
pin 7 (dipilih secara acak) ke tombol tekan, dan menghubungkan tombol tekan
melalui 10k resistor ke ground pin. Kemudian hubungkan power supply 5 volt ke
pin lain dari tombol. Semua dalam semua, pendekatan ini tampaknya mudah, tapi
mengapa kita perlu resistor lagi?
Masalahnya adalah bahwa kita mengharapkan tombol tekan untuk kembali
nilai default (LOW) dalam kasus ini tidak ditekan. Tapi ketika tombol tidak
ditekan, tidak akan langsung terhubung ke tanah dan akan berkedip karena statis
dan gangguan. Sedikit arus mengalir melalui resistor, dan ini membantu
mencegah gangguan acak dari mengubah tegangan bahwa pin input melihat.
38
pinMode(BUTTON_PIN, INPUT);
}
void loop() {
const int BUTTON_STATE = digitalRead(BUTTON_PIN);
if (BUTTON_STATE == HIGH)
digitalWrite(LED_PIN, HIGH);
else
digitalWrite(LED_PIN, LOW);
}
39
10
- void loop(){
- const int CURRENT_BUTTON_STATE = digitalRead(BUTTON_PIN);
-
- if (CURRENT_BUTTON_STATE == HIGH){
15 led_state = (led_state == LOW) ? HIGH : LOW;
- digitalWrite(LED_PIN, led_state);
-}
-}
Kita mulai dengan biasa pin konstanta, dan di setup () kita tentukan mode
pin yang kita gunakan. Sejalan 9, kita mendefinisikan variabel bernama led_state
global yang untuk menyimpan kondisi saat LED kita. Ini akan menjadi LOW
ketika LED adalah dan TINGGI sebaliknya. Dalam loop (), kita cek negara
tombol saat ini. Ketika kita menekan tombol, negara yang beralih ke TINGGI, dan
kita mengaktifkan isi led_state.
Artinya, jika led_state adalah TINGGI, kita set ke LOW, dan sebaliknya.
Pada akhirnya, kita mengatur negara LED fisik untuk saat ini kita state perangkat
lunak yang sesuai. Solusi kita adalah benar-benar sederhana, tapi sayangnya, tidak
bekerja. Putar main dengan itu sedikit, dan Anda akan segera melihat beberapa
perilaku yang mengganggu.
Jika Anda menekan tombol, misalnya, kadang-kadang LED akan menyala
dan kemudian pergi dengan segera. Juga, jika Anda melepaskannya, LED akan
sering tetap berada dalam keadaan kurang lebih sewenang-wenang, yaitu, kadang-
kadang akan berada di dan kadang-kadang off. Masalahnya adalah bahwa Arduino
mengeksekusi loop (metode) dan lebih lagi. Meskipun CPU Arduino adalah relatif
lambat, ini akan terjadi sangat sering tidak peduli apakah kita saat ini tekan
tombol atau tidak.
Tetapi jika Anda tekan dan tekan terus, negaranya akan terus menjadi
TINGGI, dan Anda akan terus-menerus beralih negara LED (karena ini terjadi
begitu cepat sepertinya LED terus-menerus). Ketika Anda melepaskan tombol,
LED berada dalam keadaan yang lebih atau kurang sewenang-wenang. Untuk
40
memperbaiki situasi, kita harus menyimpan tidak hanya saat LED negara tetapi
juga keadaan sebelumnya tombol tekan ini :
41
bekerja jauh lebih baik dari yang lama kita. Tapi Anda masih akan menemukan
beberapa kasus tepi ketika tombol tidak sepenuhnya berperilaku seperti yang
diharapkan. Masalah terutama terjadi pada saat Anda melepas tombol. Penyebab
masalah ini adalah bahwa tombol mekanik bangkit untuk beberapa milidetik
ketika Anda menekan mereka.
Tepat setelah Anda memiliki menekan tombol, Arduino tidak
memancarkan sinyal yang jelas. Untuk mengatasi hal ini Akibatnya, Anda harus
menghilangkan bounce tombol. Ini biasanya cukup untuk menunggu periode
singkat waktu sampai sinyal tombol yang stabil. debouncing memastikan bahwa
kita bereaksi hanya sekali untuk menekan tombol. tambahan untuk debouncing,
kita masih harus menyimpan keadaan saat ini LED dalam variabel. Berikut adalah
cara untuk melakukannya:
42
- old_button_state = CURRENT_BUTTON_STATE;
-}
Ini versi final switch LED kita berbeda dari yang sebelumnya di hanya
satu baris: untuk menghilangkan bounce tombol, kita tunggu 50 milidetik sejalan
19 sebelum kita memasuki loop utama lagi. Ini adalah segalanya yang perlu Anda
ketahui tentang tombol tekan untuk saat ini. dalam bagian berikutnya, kita akan
menggunakan dua tombol untuk mengubah dadu biner kita menjadi nyata game.
43
randomSeed(analogRead(A0));
}
int current_value = 0;
int old_value = 0;
void loop() {
current_value = digitalRead(BUTTON_PIN);
if (current_value!= old_value && current_value == HIGH){
output_result(random(1, 7));
delay(50);
}
old_value = current_value;
}
void output_result(const long result) {
digitalWrite(LED_BIT0, result & B001);
digitalWrite(LED_BIT1, result & B010);
digitalWrite(LED_BIT2, result & B100);
}
- void loop(){
- const int CURRENT_BUTTON_STATE = digitalRead(BUTTON_PIN);
- if (CURRENT_BUTTON_STATE!= old_button_state &&
15 CURRENT_BUTTON_STATE == HIGH)
-{
- led_state = (led_state == LOW) ? HIGH : LOW;
- digitalWrite(LED_PIN, led_state);
- delay(50);
20 }
- old_button_state = CURRENT_BUTTON_STATE;
-}
Itu gabungan sempurna dari kode asli dan kode yang diperlukan untuk
kontrol tombol debounced. Seperti biasa, kita menginisialisasi semua pin yang
kita gunakan : tiga untuk LED dan satu input pin untuk tombol pin output. Kita
44
juga menginisialisasi benih acak, dan dalam lingkaran () fungsi kita tunggu baru
menekan tombol. Setiap kali tombol ditekan akan, kita melempar dadu dan output
hasil menggunakan LED. Kita telah digantikan tombol reset dengan kita sendiri!
Sekarang kita tahu betapa mudahnya untuk menambahkan tombol tekan, kita akan
menambah satu di bagian berikutnya untuk mengubah dadu sederhana kita
menjadi sebuah permainan.
45
salahnya untuk membaca petunjuk instalasi dan dokumentasi di halaman web.
Berikut versi final dari kode biner dadu kita:
#include <Bounce.h>
-
- const unsigned int LED_BIT0 = 12;
- const unsigned int LED_BIT1 = 11;
5 const unsigned int LED_BIT2 = 10;
- const unsigned int START_BUTTON_PIN = 5;
- const unsigned int GUESS_BUTTON_PIN = 7;
- const unsigned int BAUD_RATE = 9600;
-
10 void setup(){
- pinMode(LED_BIT0, OUTPUT);
- pinMode(LED_BIT1, OUTPUT);
- pinMode(LED_BIT2, OUTPUT);
- pinMode(START_BUTTON_PIN, INPUT);
15 pinMode(GUESS_BUTTON_PIN, INPUT);
- randomSeed(analogRead(A0));
- Serial.begin(BAUD_RATE);
-}
-
20 const unsigned int DEBOUNCE_DELAY = 20;
- Bounce start_button(START_BUTTON_PIN, DEBOUNCE_DELAY);
- Bounce guess_button(GUESS_BUTTON_PIN, DEBOUNCE_DELAY);
- int guess = 0;
-
25 void loop(){
- handle_guess_button();
- handle_start_button();
-}
-
46
30 void handle_guess_button(){
- if (guess_button.update()){
- if (guess_button.read() == HIGH){
- guess = (guess % 6) + 1;
- output_result(guess);
35 Serial.print("Guess:”);
- Serial.println(guess);
-}
-}
-}
40
- void handle_start_button(){
- if (start_button.update()){
- if (start_button.read() == HIGH){
- const int result = random(1, 7);
45 output_result(result);
Serial.print("Result:”);
- Serial.println(result);
- if (guess > 0){
- if (result == guess){
50 Serial.println("You win!");
- hooray();
- } else{
- Serial.println("You lose!");
-}
55 }
- delay(2000);
- guess = 0;
-}
-}
60 }
-
47
- void output_result(const long result){
- digitalWrite(LED_BIT0, result & B001);
- digitalWrite(LED_BIT1, result & B010);
65 digitalWrite(LED_BIT2, result & B100);
-}
-
- void hooray(){
- for (int i = 0; i < 3; i++){
70 output_result(7);
- delay(500);
- output_result(0);
- delay(500);
-}
75 }
Diakui bahwa banyak kode, tapi kita tahu sebagian besar sudah, dan
bagian-bagian baru cukup mudah. Pada baris pertama, kita termasuk library
Bounce kita akan menggunakan nanti untuk menghilangkan bounce dua tombol
kita. Kemudian kita mendefinisikan konstanta untuk semua pin yang kita
gunakan, dan di setup () metode, kita menginisialisasi semua kita pin dan
mengatur benih acak. Kita juga menginisialisasi port serial, karena kita akan
keluaran beberapa pesan debug. The Bounce library menyatakan kelas bernama
Bounce, dan Anda harus membuat objek Bounce untuk setiap tombol yang ingin
Anda menghilangkan bounce. Itulah yang terjadi di jalur 21 dan 22.
Konstruktor dari kelas Bounce mengharapkan jumlah pin tombol yang
terhubung ke dan menghilangkan bounce yang keterlambatan dalam milidetik.
Akhirnya, kita menyatakan dan menginisialisasi variabel bernama menebak yang
menyimpan dugaan kita saat ini. Our lingkaran () fungsi telah dikurangi menjadi
dua fungsi panggilan. salah satunya adalah bertanggung jawab untuk menangani
tombol menebak dorongan, dan yang lain menangani dorongan dari tombol start.
Dalam handle_guess_button (), kita menggunakan Bounce Class untuk pertama
kalinya.
48
Untuk menentukan keadaan saat ini kita guess_button objek, kita harus
memanggil update () method. Setelah itu, kita membaca status saat ini
menggunakan read () method. Jika tombol ditekan, negara yang diatur ke
TINGGI, dan kita kenaikan variabel menebak. Untuk memastikan bahwa tebakan
selalu dalam kisaran antara 1 dan 6, kita menggunakan operator modulus (%)
sejalan 33. ini Operator membagi dua nilai dan mengembalikan sisanya. Untuk 6,
ia mengembalikan nilai antara 0 dan 5, karena ketika Anda membagi angka
dengan 6, yang sisanya selalu antara 0 dan 5.
Tambahkan 1 pada hasil, dan Anda mendapatkan nilai antara 1 dan 6.
Akhirnya, kita menebak saat ini menggunakan tiga LED, dan kita juga mencetak
ke port serial. Penanganan tombol start di handle_start_button () bekerja sama
persis sama seperti penanganan tombol menebak. Ketika tombol start ditekan, kita
menghitung hasil baru dan output pada port serial. Kemudian kita cek apakah
pengguna telah memasuki menebak (menebak lebih besar dari nol dalam kasus
ini) dan apakah pengguna telah menebak kanan hasil. Dalam kedua kasus, kita
mencetak pesan ke port serial, dan jika pengguna menebak dengan benar, kita
juga memanggil hore () method. hore () memungkinkan semua tiga LED berkedip
beberapa kali.
Pada akhir metode ini, kita menunggu selama dua detik sampai pertandingan
dimulai lagi, dan kita mengatur kembali menebak saat ini ke nol.
Setelah Anda meng-upload software ke Arduino, mulai seri IDE
memantau. Ini akan mencetak nilai sekarang dari variabel menebak setiap kali
Anda menekan tombol menebak. Tekan tombol start, dan hasil baru muncul.
Dalam bab ini, Anda menyelesaikan proyek Arduino benar-benar kompleks
pertama Anda. Anda membutuhkan breadboard, LED, tombol, resistor, dan kabel,
dan Anda menulis sepotong trivial perangkat lunak untuk membuat semua
perangkat keras datang ke hidup. Pada bab selanjutnya, kita akan menulis sebuah
program yang lebih canggih untuk menghasilkan kode Morse. Anda juga akan
belajar cara membuat Arduino sendiri library yang Anda dapat dengan mudah
berbagi dengan seluruh dunia.
49
3.8 Kesalahan-kesalahan yang Mungkin Terjadi
Banyak hal mungkin akan salah bila Anda bekerja dengan breadboards
untuk pertama kalinya. Masalah terbesar biasanya adalah bahwa Anda tidak
terhubung bagian dengan benar. Butuh beberapa waktu untuk menemukan teknik
yang tepat untuk memasukkan LED, kabel, resistor, dan tombol ke papan tempat
breadboard. Anda memiliki untuk menekan tegas tapi tidak terlalu keras jika
tidak, anda akan menekuk konektor, dan mereka tidak akan cocok. Ini biasanya
lebih mudah untuk plug bagian dalam setelah Anda dipersingkat konektor.
Ketika memotong konektor, memakai kacamata keselamatan untuk
melindungi mata Anda! Sementara mengutak-atik main dengan bagian-bagian,
jangan lupa bahwa beberapa dari mereka - LED, misalnya - membutuhkan arah
tertentu. Pushbuttons adalah kandidat potensi masalah, juga. Perhatikan pada
pushbuttons pada halaman 74 dan pastikan bahwa Anda telah terpasang mereka
ke arah yang benar.
Bahkan hal-hal sederhana seperti kabel biasa dapat menyebabkan masalah,
terutama jika mereka tidak panjang yang tepat. Jika kawat terlalu pendek dan
mungkin berpotensi menyelinap keluar dari soketnya, menggantinya segera.
Kabel terlalu murah untuk membuang waktu berharga Anda dengan tidak perlu
dan mengganggu sesi debugging.
3.9 Latihan
• Dadu Binary semua sangat baik ketika Anda sedang bermain Monopoli dengan
teman geeky Anda, tetapi kebanyakan orang lebih memilih dadu lebih akrab. coba
mengubah dadu biner ke desimal dadu dengan tujuh LED. mengatur LED seperti
mata dadu biasa.
• 1k resistor kita telah digunakan untuk melindungi LED kita dalam bab ini agak
besar.
• LED dapat digunakan untuk lebih dari menampilkan hasil dadu biner. Asalkan
Anda memiliki cukup LED, Anda dapat dengan mudah membangun hal-hal lain,
50
biner Anda sudah cukup tahu tentang elektronika dan pemrograman Arduino
untuk membangun jam biner Anda sendiri. Cobalah atau berpikir tentang lainnya
hal yang bisa menampilkan menggunakan beberapa LED.
• Menggunakan tombol untuk melempar dadu tampaknya sedikit canggung,
bukan? Biasanya, Anda mengambil dadu ke kedua tangan dan kocok mereka.
Anda dapat mudah mensimulasikan bahwa dengan sensor kemiringan. Sensor
kemiringan mendeteksi tilting dari obyek dan perangkat sempurna untuk
mensimulasikan gulungan dadu. Pada prinsipnya, mereka bekerja seperti tombol
tekan, tapi Anda tidak menekan mereka - Anda kocok mereka. Cobalah untuk
menambahkan satu untuk dadu biner dengan bekerja jalan Anda melalui tutorial
pada Situs Arduino.
51
Membuat Morse Code
Generator Library
Sekarang Anda cukup tahu tentang lingkungan pengembangan Arduino
dan sekitar berkedip LED untuk memulai sebuah proyek yang lebih besar. Dalam
bab ini, kita akan mengembangkan generator kode Morse yang membaca teks dari
port serial dan output sebagai sinyal cahaya menggunakan LED. Dengan
membangun proyek ini, Anda akan memperdalam pemahaman Anda tentang seri
komunikasi antara Arduino dan komputer Anda. Anda juga akan belajar banyak
tentang proses pengembangan khas Arduino : bagaimana menggunakan library
yang ada dan bagaimana struktur proyek yang lebih besar ke Anda sendiri library.
Pada akhirnya, Anda akan dapat membuat library yang siap penerbitan di Internet.
52
garis (juga disebut dits dan dahs). Dits lebih pendek panjang dari dahs. Sebuah A
dikodekan sebagai · - dan - · adalah Z.
Kode Morse juga menetapkan skema waktu yang mendefinisikan panjang
dits dan dahs. Hal ini juga menentukan berapa lama jeda antara simbol dan kata-
kata harus. Unit dasar kode Morse adalah panjang dit a, dan da h adalah selama
tiga dits. Anda menyisipkan jeda satu dit antara dua simbol, dan Anda
memisahkan dua surat oleh tiga dits. Menyisipkan jeda tujuh dits antara dua kata.
Untuk mengirimkan pesan dikodekan dalam kode Morse, Anda perlu cara
untuk memancarkan sinyal dengan panjang yang berbeda. Pendekatan klasik
adalah dengan menggunakan suara, tetapi kita akan menggunakan LED yang
diaktifkan dan dinonaktifkan untuk jangka waktu yang berbeda-beda dari waktu
ke waktu. Pelaut masih mengirimkan kode Morse menggunakan lampu berkedip.
Mari kita menerapkan kode Morse Generator!
53
Semua file dan direktori yang kita butuhkan untuk kita library akan
disimpan dalam folder EGR aph Tel. Sekarang buka tab baru, dan ketika ditanya
tentang nama file, masukkan telegraph.h. Ya, kita akan menciptakan sebuah file
header C tua yang baik (harus tepat, bahkan akan C + + file header). Daftar di di
halaman berikutnya.
#ifndef __TELEGRAPH_H__
#define __TELEGRAPH_H__
class Telegraph {
public:
Telegraph(const int output_pin, const int dit_length);
void send_message(const char* message);
private:
void dit();
void dah();
void output_code(const char* code);
void output_symbol(const int length);
int _output_pin;
int _dit_length;
int _dah_length;
};
#endif
Ini adalah deskripsi interface dari Tel EGR kelas aph bahwa Anda bisa
digunakan dalam proyek perusahaan berikutnya (dengan syarat bahwa Anda perlu
mengirimkan beberapa informasi sebagai kode Morse, yaitu). Kita mulai dengan
mekanisme pencegahan double- termasuk klasik, bahwa yaitu, tubuh file header
mendefinisikan makro preprocessor dengan nama __TELEGRAPH_H__.
Kita membungkus tubuh (yang berisi definisi ini) dalam # ifndef, sehingga
tubuh hanya memenuhi jika makro belum didefinisikan. Dengan begitu, Anda
dapat menyertakan header sebanyak yang Anda inginkan, dan tubuh hanya akan
dikompilasi sekali. Antarmuka dari Telegraph kelas terdiri dari bagian umum
54
yang pengguna kelas memiliki akses ke dan bagian pribadi hanya anggota kelas
dapat menggunakan.
Di bagian umum, Anda menemukan dua hal : konstruktor yang
menciptakan objek Telegraph baru dan metode bernama send_message () yang
mengirim pesan dengan memancarkan sebagai kode Morse. Dalam aplikasi Anda,
Anda dapat menggunakan kelas sebagai berikut :
#include <ctype.h>
#include <WProgram.h>
#include”telegraph.h"
char* LETTERS[] = {
".-",”-...",”-.-.",”-..",”.", // A-E
"..-.",”--.",”....",”..",”.---", // F-J
"-.-",”.-..",”--",”-.",”---", // K-O
".--.",”--.-",”.-.",”...",”-", // P-T
55
"..-",”...-",”.--",”-..-",”-.--", // U-Y
"--..”//Z
};
char* DIGITS[] ={
"-----",”.----",”..---",”...--", // 0-3
"....-",”.....",”-....",”--...", // 4-7
"---..",”----.”// 8-9
};
56
Telegraph::Telegraph(const int output_pin, const int dit_length) {
_output_pin = output_pin;
_dit_length = dit_length;
_dah_length = dit_length * 3;
pinMode(_output_pin, OUTPUT);
}
57
output_symbol(_dit_length);
}
void Telegraph::dah() {
Serial.print("-");
output_symbol(_dah_length);
}
void Telegraph::output_symbol(const int length) {
digitalWrite(_output_pin, HIGH);
delay(length);
digitalWrite(_output_pin, LOW);
}
Fungsi output_code () mengambil urutan kode Morse yang terdiri dari titik
dan garis dan mengubahnya menjadi panggilan ke Dit () dan dah (). Dit () dan dah
() metode kemudian mencetak titik atau tanda hubung ke port serial dan
mendelegasikan sisa pekerjaan untuk output_symbol (), lewat itu panjang Morse
simbol kode yang akan dipancarkan.
output_symbol () menetapkan pin output TINGGI untuk panjang simbol,
dan kemudian menetapkan kembali ke LOW. semuanya bekerja sama persis
seperti yang dijelaskan dalam skema kode Morse waktu, dan hanya pelaksanaan
send_message () hilang:
58
- Serial.print(“");
- delay(_dit_length * 7);
-}
-}
15 Serial.println();
-}
59
Kelas Telegraph kita selesai, dan sekarang kita harus membuat beberapa
contoh sketsa yang benar-benar menggunakannya. Hal ini penting karena dua
alasan : kita dapat menguji kode library kita, dan bagi pengguna kelas kita itu
dokumentasi yang baik untuk bagaimana menggunakannya. Arduino IDE mencari
library di dua tempat : di library global folder relatif terhadap direktori instalasi
dan sketsa lokal pengguna direktori. Selama pengembangan yang terbaik untuk
menggunakan sketsa lokal direktori. Anda dapat menemukan lokasi di preferensi
IDE. Buat direktori baru bernama library didirektori sketsa. Untuk membuat kita
Tel kelas EGR aph tersedia, membuat subfolder Telegraph di folder library.
Kemudian salin telegraph.h dan telegraph.cpp ke folder itu (jangan copy
Telegraph pde.). Restart IDE. Mari kita mulai dengan ibu dari semua program
:”Halo, dunia”Buat baru sketsa bernama HelloWorld, dan masukkan kode berikut
::
#include”telegraph.h"
const unsigned int OUTPUT_PIN = 13;
const unsigned int DIT_LENGTH = 200;
Telegraph telegraph(OUTPUT_PIN, DIT_LENGTH);
void setup() {}
void loop() {
telegraph.send_message("Hello, world!");
delay(5000);
}
60
dalam library, Anda akan diberitahu sekarang. Jika Anda harus memperbaiki
beberapa kesalahan, pastikan Anda mengubah file kode sumber asli Anda. Setelah
Anda tetap kesalahan, salin file ke library folder lagi, dan jangan lupa untuk me-
restart IDE.
Menghidupkan string statis ke dalam kode Morse bagus, tapi tidak akan
menjadi besar jika program kita bisa bekerja untuk string sewenang-wenang? Jadi,
mari kita tambahkan lebih Contoh canggih. Kali ini, kita akan menulis kode yang
bertuliskan pesan dari port serial dan feed mereka ke Telegraph misalnya. Buat
sketsa baru bernama MorseCodeGenerator, dan masukkan kode berikut:
#include”telegraph.h"
const unsigned int OUTPUT_PIN = 13;
const unsigned int DIT_LENGTH = 200;
const unsigned int MAX_MESSAGE_LEN = 128;
const unsigned int BAUD_RATE = 9600;
const int LINE_FEED = 13;
char message_text[MAX_MESSAGE_LEN];
int index = 0;
Telegraph telegraph(OUTPUT_PIN, DIT_LENGTH);
void setup(){
Serial.begin(BAUD_RATE);
}
void loop() {
if (Serial.available() > 0){
int current_char = Serial.read();
if (current_char == LINE_FEED || index == MAX_MESSAGE_LEN - 1){
message_text[index] = 0;
index = 0;
telegraph.send_message(message_text);
} else {
message_text[index++] = current_char;
}
61
}
}
Sekali lagi, kita menyertakan file header dari Telegraph kelas, dan seperti
yang kita biasa mendefinisikan beberapa konstanta: OUTPUT_PIN
mendefinisikan pin LED kita terhubung untuk, dan DIT_LENGTH berisi panjang
dari dit diukur dalam milidetik. LINE_FEED diatur ke kode ASCII dari karakter
linefeed. Kita membutuhkannya untuk menentukan akhir pesan yang akan
dipancarkan sebagai kode Morse. akhirnya, kita set MAX_MESSAGE_LEN
dengan panjang maksimum pesan yang kita dapat mengirim.
62
kita tidak bisa mendapatkan keuntungan dari keuntungan pemrograman
berorientasi objek.
Namun, kita memiliki beberapa hal-hal kecil yang harus dilakukan untuk
mengubah proyek kita menjadi sebuah firstclass library. Baca lebih lanjut tentang
hal ini pada bagian berikutnya.
Salah satu fitur bagus dari Arduino IDE adalah pewarnaan sintaks. kelas
nama, nama fungsi, variabel, dan sebagainya, semua memiliki warna yang
berbeda di editor. Hal ini membuat lebih mudah untuk membaca kode sumber,
dan itu mungkin untuk menambah pewarnaan sintaks untuk library. Anda hanya
perlu menambahkan file bernama keywords.txt untuk proyek Anda :
Setiap contoh sketsa harus mendapatkan sendiri subdirektori dalam folder itu.
63
• Pilih lisensi untuk proyek Anda, dan menyalin istilah ke dalam sebuah file
bernama LICENSE.4 Anda mungkin berpikir ini adalah sedikit di atas untuk
banyak library, tetapi akan memberikan kepercayaan pemirsa potensial Anda.
• Tambahkan petunjuk instalasi dan dokumentasi. Biasanya, pengguna berharap
untuk menemukan dokumentasi dalam sebuah file bernama README, dan
mereka akan mencari instruksi penginstalan dalam sebuah file bernama
INSTALL. anda harus mencoba untuk menginstal library Anda pada banyak
sistem operasi seperti mungkin dan memberikan petunjuk instalasi untuk mereka
semua. Akhirnya, membuat arsip ZIP yang berisi semua file dalam proyek Anda.
pada sebagian besar sistem operasi, itu cukup untuk klik kanan direktori di
Explorer, Finder, atau apa pun yang Anda gunakan dan mengubah direktori ke
arsip ZIP.
Pada sistem Linux dan pada Mac, Anda juga dapat menggunakan salah
satu dari berikut laporan baris perintah untuk membuat sebuah arsip :
64
memvisualisasikan data bahwa Arduino mengirimkan untuk program yang
berjalan pada komputer Anda.
Arduino IDE memiliki pendapat yang kuat tentang penamaan file dan
direktori, dan itu dibangun untuk membuat sketsa, bukan library. Jadi, Anda perlu
melakukan beberapa operasi file pengguna untuk mendapatkan segala sesuatu ke
kanan tempat Jika Anda memiliki lebih dari satu versi dari Arduino IDE diinstal,
pastikan bahwa Anda menggunakan folder library yang tepat. Ingat bahwa Anda
harus me-restart IDE sering. Setiap kali Anda mengubah salah satu file milik
library Anda, restart IDE.
Jika pewarnaan sintaks tidak bekerja, pastikan berkas kata kunci Anda
sebenarnya bernama keywords.txt. Periksa ulang jika Anda telah memisahkan
semua benda dan ketik specifier oleh karakter tab! Restart IDE Anda!
4.9 Latihan
• Kode Morse mendukung tidak hanya huruf dan angka. Hal ini juga
mendefinisikan simbol seperti koma. Meningkatkan Telegraph kelas sehingga
mengerti semua karakter dari kode Morse.
• LED bisa digunakan, tetapi ketika kita berpikir tentang kode Morse, kita
biasanya berpikir tentang bunyi suara, sehingga mengganti LED dengan piezo
speaker, yang murah dan mudah digunakan. Mereka memiliki pin ground dan
sinyal pin, jadi menghubungkan tanah pembicara ke tanah Arduino itu, dan
menghubungkan pin sinyal ke Arduino pin 13. Kemudian ganti output_symbol ()
metode dengan kode berikut :
65
tone(_output_pin, frequency, length);
}
class OutputDevice {
public:
virtual void output_symbol(const int length);
};
class Led : public OutputDevice {
public:
void output_symbol(const int length){
//...
}
};
class Speaker : public OutputDevice {
public:
void output_symbol(const int length){
//...
}
};
66
Led led;
Speaker speaker;
OutputDevice* led_device = &led;
OutputDevice* speaker_device = &speaker;
led_device->output_symbol(200);
speaker_device->output_symbol(200);
Cobalah untuk belajar kode Morse. Biarkan orang lain mengetik beberapa
pesan ke terminal serial dan mencoba untuk mengenali apa yang dia dikirim.
67
Membuat sebuah
Motion-sensing Game
Controller
Sangat mengherankan betapa cepatnya kita terbiasa dengan teknologi
baru. Satu dekade lalu, tidak banyak orang akan membayangkan bahwa kita akan
menggunakan perangkat suatu hari nanti untuk diam-diam mengikuti gerakan kita.
Hari ini benar-benar normal bagi kita untuk secara fisik mengubah smartphone
kita ketika kita ingin mengubah dari tampilan tegak ke mendatar. Bahkan anak-
anak kecil secara intuitif tahu bagaimana menggunakan kontroler motion -sensing
untuk konsol video game seperti Nintendo Wii. Anda dapat membangun
perangkat motion -sensing Anda sendiri dengan menggunakan Arduino, dan
dalam bab ini Anda akan belajar bagaimana.
Kita akan bekerja dengan salah satu perangkat motion -sensing yang
paling luas : the accelerometer. Accelerometers mendeteksi gerakan ke segala
arah - mereka pemberitahuan jika Anda memindahkan mereka ke atas, bawah,
maju, mundur, ke kiri, atau hak. Banyak gadget populer seperti iPhone dan
Nintendo Kontroler Wii mengandung accelerometers. Itu sebabnya
accelerometers yang murah.
68
dapat menggunakannya untuk mengukur percepatan lebih atau kurang secara tidak
langsung, misalnya di dalam mobil. Anda akan belajar bagaimana untuk
menginterpretasikan data accelerometer dengan benar dan bagaimana
mendapatkan hasil yang paling akurat. Kemudian Anda akan menggunakan
accelerometer untuk membangun sendiri motion -sensing controller game Anda,
dan Anda akan menerapkan permainan yang menggunakannya.
5.2 Accelerometer
69
Sensor adalah sirkuit terpadu (IC), dan sisanya hanya pembawa untuk
memungkinkan koneksi. Di atas, Anda melihat 6 pin 0,1”header standar. Sensor
memiliki enam konektor berlabel GND, Z, Y, X, 3V, dan UJI. Untuk
menggunakan sensor pada papan breadboard, solder Header standar untuk
konektor. Hal ini tidak hanya membuat lebih mudah untuk melampirkan sensor
untuk papan breadboard tetapi juga menstabilkan sensor, sehingga
tidak bergerak secara tidak sengaja. Anda dapat melihat hasilnya di sisi kiri foto
(perhatikan bahwa papan breakout di sebelah kiri adalah tidak sama dengan di
sebelah kanan, tapi itu sangat mirip). Jangan khawatir jika Anda belum pernah
disolder sebelumnya. Anda dapat belajar bagaimana melakukannya. Anda dapat
mengabaikan konektor berlabel TEST, dan makna konektor yang tersisa harus
jelas. Untuk daya sensor, hubungkan GND ke tanah pin Arduino dan 3V ke
Arduino 3,3 volt power supply. X, Y, dan Z kemudian akan mengirimkan data
percepatan untuk x -, y -, dan z - sumbu.
70
const unsigned int BAUD_RATE = 9600;
void setup(){
Serial.begin(BAUD_RATE);
}
void loop(){
Serial.print(analogRead(X_AXIS_PIN));
Serial.print(“");
Serial.print(analogRead(Y_AXIS_PIN));
Serial.print(“");
Serial.println(analogRead(Z_AXIS_PIN));
delay(100);
}
Program uji kita adalah yang sederhana seperti itu bisa. Kita mendefinisikan
konstanta untuk tiga analog pin dan menginisialisasi port serial di setup ()
function. Perhatikan bahwa kita tidak mengatur pin analog ke INPUT eksplisit,
karena itu default pula. Dalam loop () fungsi, kita terus-menerus output nilai-nilai
yang kita baca dari pin analog ke port serial. Buka monitor seri, dan bergerak
sensor sekitar sedikit-miringkan sekitar sumbu yang berbeda. Anda harus melihat
output yang mirip dengan berikut:
71
Nilai-nilai ini merupakan data yang kita peroleh untuk x-, y-, dan z-sumbu.
kapan Anda memindahkan sensor hanya sekitar sumbu x, misalnya, Anda dapat
melihat bahwa nilai pertama perubahan sesuai. Berlaku juga untuk data banyak
sensor memancarkan, dan accelerometers tidak terkecuali. Mereka sedikit berbeda
dalam nilai-nilai minimum dan maksimum yang mereka hasilkan, dan mereka
sering Jitter sedikit.
Mereka mungkin mengubah nilai output mereka bahkan meskipun Anda
tidak bergerak mereka, atau mereka mungkin tidak mengubah output mereka
nilai-nilai dengan benar. Pada bagian ini, kita akan menentukan minimum sensor
dan nilai maksimum, dan kita akan meratakan jitter. Menemukan nilai-nilai tepi
sensor mudah, tetapi tidak dapat dengan mudah otomatis. Anda harus terus-
menerus membaca output sensor sementara bergerak itu. Berikut adalah program
yang melakukan pekerjaan:
72
Serial.print("x(");
Serial.print(min_x);
Serial.print("/");
Serial.print(max_x);
erial.print("), y(");
Serial.print(min_y);
Serial.print("/");
Serial.print(max_y);
Serial.print("), z(");
Serial.print(min_z);
Serial.print("/");
Serial.print(max_z);
Serial.println(")");
}
73
pembacaan terakhir dan kembali rata-rata mereka. Dengan cara ini, perubahan
kecil akan disetrika out. Kode terlihat sebagai berikut :
74
30 int get_y() { return get_axis(1);}
- int get_z() { return get_axis(2);}
-
- void loop(){
- Serial.print(get_x());
35 Serial.print(“");
- Serial.print(get_y());
- Serial.print(“");
- Serial.println(get_z());
-}
75
program untuk berubah. Tetapi jika Anda mengatur BUFFER_SIZE ke 1, Anda
dengan cepat akan melihat perubahan kecil. mereka akan menghilang segera
setelah buffer cukup besar. Data percepatan kita mengukur sekarang cukup akurat,
dan kita akhirnya dapat membangun sebuah game controller yang tidak akan
mengganggu pengguna karena gerakan tak terduga.
76
Sekarang bahwa hardware selesai, kita perlu versi akhir pertandingan
software pengendali. Ini mendukung tombol kita telah menambahkan, dan
melakukan anti-jittering yang telah kita buat, Mencari dan Poles Ujung Val UES,
di halaman 137:
#include <Bounce.h>
const unsigned int BUTTON_PIN = 7;
const unsigned int X_AXIS_PIN = 2;
const unsigned int Y_AXIS_PIN = 1;
const unsigned int Z_AXIS_PIN = 0;
const unsigned int NUM_AXES = 3;
const unsigned int PINS[NUM_AXES] ={
X_AXIS_PIN, Y_AXIS_PIN, Z_AXIS_PIN
};
const unsigned int BUFFER_SIZE = 16;
const unsigned int BAUD_RATE = 19200;
int buffer[NUM_AXES][BUFFER_SIZE];
int buffer_pos[NUM_AXES] = { 0 };
Bounce button(BUTTON_PIN, 20);
void setup() {
Serial.begin(BAUD_RATE);
pinMode(BUTTON_PIN, INPUT);
}
int get_axis(const int axis) {
delay(1);
buffer[axis][buffer_pos[axis]] = analogRead(PINS[axis]);
buffer_pos[axis] = (buffer_pos[axis] + 1) % BUFFER_SIZE;
long sum = 0;
for (int i = 0; i < BUFFER_SIZE; i++)
sum += buffer[axis][i];
return round(sum / BUFFER_SIZE);
}
77
int get_x() { return get_axis(0); }
int get_y() { return get_axis(1); }
int get_z() { return get_axis(2);}
void loop() {
Serial.print(get_x());
Serial.print(“");
Serial.print(get_y());
Serial.print(“");
Serial.print(get_z());
Serial.print(“");
if (button.update())
Serial.println(button.read() == HIGH ?”1”:”0");
else
Serial.println("0");
}
78
Sebuah game controller buatan sendiri bagus, tapi apakah tidak akan
bahkan lebih baik jika kita juga memiliki permainan yang mendukungnya? Itulah
apa yang akan kita membangun di akhir bab.
import processing.serial.*;
Serial arduinoPort;
79
final int BRICK_WIDTH = 40;
final int BRICK_HEIGHT = 20;
final int MARGIN = 10;
final int WIDTH = COLUMNS * BRICK_WIDTH + 2 * MARGIN;
final int HEIGHT = 300;
final int X_AXIS_MIN = 252;
final int X_AXIS_MAX = 443;
final int LINE_FEED = 10;
final int BAUD_RATE = 19200;
Kita menyimpan x saat bola 'dan y koordinat di px dan py. untuk yang x saat ini
dan kecepatan y, kita menggunakan vx dan vy. Kita menyimpan dayung itu x
posisi dalam xpos. batu bata adalah array dua dimensi dan berisi keadaan saat ini
batu bata di layar. Jika elemen array diatur ke 1, yang sesuai bata masih di layar. 0
berarti bahwa telah hancur sudah. Akhirnya, kita perlu menyimpan kemungkinan
kondisi permainan:
80
boolean done = true;
void setup() {
size(WIDTH, HEIGHT);
noCursor();
textFont(loadFont("Verdana-Bold-36.vlw"));
initGame();
println(Serial.list());
arduinoPort = new Serial(this, Serial.list()[0], BAUD_RATE);
arduinoPort.bufferUntil(LINE_FEED);
}
void initGame() {
initBricks();
initBall();
}
void initBricks() {
for (int x = 0; x < COLUMNS; x++)
for (int y = 0; y < ROWS; y++)
bricks[x][y] = 1;
}
void initBall() {
px = width / 2;
py = height / 2;
vx = int(random(-MAX_VELOCITY, MAX_VELOCITY));
vy = -2;
81
}
void draw() {
background(0);
stroke(255);
strokeWeight(3);
done = drawBricks();
if (done){
paused = true;
printWinMessage();
}
if (paused)
printPauseMessage();
else
updateGame();
drawBall();
drawPaddle();
}
Kita menghapus layar dan cat itu hitam dengan menggunakan latar belakang ().
Kemudian kita mengatur warna stroke putih dan berat stroke tiga piksel. setelah
bahwa kita menarik batu bata yang tersisa. Jika tidak ada batu bata yang tersisa,
82
kita menghentikan sementara permainan dan mencetak”Anda Menang!”pesan.
Jika permainan dihentikan sementara, kita mencetak pesan yang sesuai, dan jika
tidak, kita memperbarui kondisi permainan saat ini. Akhirnya, kita menarik bola
dan mendayung di posisi mereka saat menggunakan fungsi-fungsi berikut:
boolean drawBricks() {
boolean allEmpty = true;
for (int x = 0; x < COLUMNS; x++){
for (int y = 0; y < ROWS; y++) {
if (bricks[x][y] > 0){
allEmpty = false;
fill(0, 0, 100 + y * 8);
rect(
MARGIN + x * BRICK_WIDTH,
MARGIN + y * BRICK_HEIGHT,
BRICK_WIDTH,
BRICK_HEIGHT
);
}
}
}
return allEmpty;
}
void drawBall() {
strokeWeight(1);
fill(128, 0, 0);
ellipse(px, py, BALL_DIAMETER, BALL_DIAMETER);
}
void drawPaddle() {
int x = xpos - PADDLE_WIDTH / 2;
int y = height - (PADDLE_HEIGHT + MARGIN);
strokeWeight(1);
83
fill(128);
rect(x, y, PADDLE_WIDTH, PADDLE_HEIGHT);
}
Seperti yang Anda lihat, bola tidak lain adalah lingkaran, dan batu bata dan
dayung adalah persegi panjang sederhana. Untuk membuat mereka terlihat lebih
menarik, kita memberi mereka perbatasan bagus. Mencetak pesan permainan
mudah, juga:
void printWinMessage() {
fill(255);
textSize(36);
textAlign(CENTER);
text("YOU WIN!", width / 2, height * 2 / 3);
}
void printPauseMessage() {
fill(128);
textSize(16);
textAlign(CENTER);
text("Press Button to Continue", width / 2, height * 5 / 6);
}
void updateGame() {
if (ballDropped()){
initBall();
paused = true;
} else {
checkBrickCollision();
checkWallCollision();
84
checkPaddleCollision();
px += vx;
py += vy;
}
}
Ketika pemain tidak memukul bola dengan dayung dan tetes keluar dari playfield,
permainan berhenti, dan pengguna diijinkan untuk melanjutkan setelah menekan
tombol. Dalam pertandingan final, Anda akan menurunkan beberapa jenis
kehidupan counter dan cetak”Game Over”pesan ketika counter mencapai nol. Jika
bola masih dalam bermain, kita memeriksa untuk berbagai tabrakan. Kita
memeriksa apakah bola telah mencapai satu atau lebih batu bata, jika telah
menabrak dinding, atau jika telah memukul dayung. Kemudian kita menghitung
posisi baru bola. Pemeriksaan tabrakan terlihat rumit, tetapi mereka cukup
sederhana dan hanya membandingkan bola berkoordinasi dengan koordinat semua
benda lain pada layar:
boolean ballDropped() {
return py + vy > height - BALL_RADIUS;
}
boolean inXRange(final int row, final int v) {
return px + v > row * BRICK_WIDTH &&
px + v < (row + 1) * BRICK_WIDTH + BALL_DIAMETER;
}
boolean inYRange(final int col, final int v) {
return py + v > col * BRICK_HEIGHT &&
py + v < (col + 1) * BRICK_HEIGHT + BALL_DIAMETER;
}
void checkBrickCollision() {
for (int x = 0; x < COLUMNS; x++){
for (int y = 0; y < ROWS; y++) {
if (bricks[x][y] > 0){
85
if (inXRange(x, vx) && inYRange(y, vy)) {
bricks[x][y] = 0;
if (inXRange(x, 0)) // Hit top or bottom of brick.
vy = -vy;
if (inYRange(y, 0)) // Hit left or right side of brick.
vx = -vx;
}
}
}
}
}
void checkWallCollision() {
if (px + vx < BALL_RADIUS || px + vx > width - BALL_RADIUS)
vx = -vx;
if (py + vy < BALL_RADIUS || py + vy > height - BALL_RADIUS)
vy = -vy;
}
void checkPaddleCollision() {
final int cx = xpos;
if (py + vy >= height - (PADDLE_HEIGHT + MARGIN + 6) &&
px >= cx - PADDLE_WIDTH / 2 &&
px <= cx + PADDLE_WIDTH / 2)
{
vy = -vy;
vx = int(
map(
px - cx,
-(PADDLE_WIDTH / 2), PADDLE_WIDTH / 2,
-MAX_VELOCITY,
MAX_VELOCITY
)
);
86
}
}
87
masing baris berisi percepatan saat ini x -, y -, dan z - sumbu dan keadaan saat
tombol. Ini memisahkan semua atribut dengan kosong. Jadi, dalam serialEvent (),
kita membaca baris baru, split pada karakter kosong, dan mengkonversi string
dihasilkan menjadi nilai int. Ini semua terjadi di baris 5. Kita memeriksa apakah
kita benar-benar mendapat semua empat atribut, dan kemudian kita melihat
apakah pemain telah menekan tombol pada kontroler game. jika ya, kita beralih
keadaan jeda : jika permainan saat berada dalam mode jeda, kita melanjutkan
permainan, jika tidak, kita pause.
Kita juga harus memeriksa apakah permainan telah selesai. Jika ya, kita
memulai permainan baru. Akhirnya, kita membaca X akselerasi saat ini di baris
17 dan peta itu ke posisi x kemungkinan dayung kita. Itu benar-benar semua yang
harus kita lakukan untuk memindah pemukul menggunakan game controller kita
sendiri. Juga, tidak masalah jika Anda menggunakan controller untuk mengontrol
permainan atau jenis yang sama sekali berbeda perangkat lunak. Anda hanya perlu
membaca empat nilai integer dari serial pelabuhan ketika Anda membutuhkannya.
Pada bagian ini, Anda telah belajar lebih banyak tentang pemrograman
game daripada tentang pemrograman Arduino atau perangkat keras. Tapi Anda
harusnya telah belajar bahwa sangat mudah untuk mengintegrasikan elektronik
yang dirancang dengan baik proyek ke proyek perangkat lunak biasa. Kita dengan
hati-hati menganalisis data analog dikembalikan oleh accelerometer, dan
kemudian kita menghapus semua jitter yang tidak diinginkan. Ini adalah teknik
yang akan Anda gunakan sering dalam elektronik Anda proyek, dan kita akan
menggunakannya lagi di bab berikutnya.
Jika Anda menjaga mata Anda terbuka, Anda akan segera menemukan
lebih banyak aplikasi untuk accelerometers daripada yang Anda bayangkan.
Berikut adalah koleksi kecil baik komersial dan gratis produk :
• Nike iPod Sport Kit mendukung Anda dalam latihan sehari-hari Anda, dan itu
didasarkan pada accelerometer, juga.
88
• Ini sangat menyenangkan untuk membuat marmer labirin permainan komputer
dan kontrol menggunakan kontroler game kita membangun dalam bab ini.
• Dalam bab ini, kita telah diukur hanya percepatan langsung; bahwa adalah, kita
biasanya memiliki accelerometer di tangan kita dan memindahkannya.
6.9 Latihan
89
Jaringan Arduino
Dengan Arduino standalone, Anda dapat membuat proyek-proyek yang
tak terhitung jumlahnya menyenangkan dan berguna. Tapi segera setelah Anda
mengubah Arduino menjadi perangkat jaringan, Anda membuka berbagai
kemungkinan baru. Anda sekarang memiliki akses ke semua informasi di internet,
sehingga Anda bisa mengubah Arduino Anda menjadi stasiun cuaca hanya dengan
membaca data dari layanan cuaca. Anda juga dapat mengubah Arduino menjadi
web server yang menyediakan data sensor untuk perangkat lain atau komputer
pada Anda di web.
Dalam proyek akan membangun sebuah alarm pencuri email dalam bab
ini. mendeteksi gerak dalam ruang tamu Anda, dan Arduino akan mengirimkan
email ketika mendeteksi gerakan selama ketidakhadiran Anda. Karena ini adalah
proyek agak maju, pertama-tama kita akan bekerja pada beberapa proyek-proyek
kecil untuk mempelajari semua teknik dan keterampilan yang diperlukan.
Kita akan mulai dengan”telanjang”Arduino yang tidak memiliki kemampuan
jaringan.
Ini akan mengubah Arduino Anda menjadi jam yang sangat akurat.
Setelah kita dapat untuk mengakses layanan IP, maka kita akan belajar bagaimana
untuk mengirim email langsung dari Arduino dengan perisai Ethernet. Untuk
alarm pencuri, kita kemudian hanya perlu tahu bagaimana untuk mendeteksi
gerakan. Dalam hal ini, kita akan menggunakan sensor inframerah pasif ( PIR ).
90
6.1 Yang Anda Butuhkan
91
-
- void setup(){
- Serial.begin(BAUD_RATE);
-}
10
- void loop(){
- const int sensor_voltage = analogRead(TEMP_SENSOR_PIN);
- const float voltage = sensor_voltage * SUPPLY_VOLTAGE / 1024;
- const float celsius = (voltage * 1000 - 500) / 10;
15 #ifdef CELSIUS
- Serial.print(celsius);
- Serial.println(“C");
- #else
- Serial.print(9.0 / 5.0 * celsius + 32.0);
20 Serial.println(“F");
- #endif
- delay(5000);
-}
Ini hampir sketsa yang sama kita telah digunakan sebelumnya. Perlu
diingat bahwa Anda harus menetapkan SUPPLY_VOLTAGE menjadi 3,3 di baris
5, jika Anda menggunakan Arduino yang berjalan dengan 3.3V bukan 5V.
Kita mendukung baik Celcius dan Fahrenheit nilai sekarang, dan Anda dapat
mengontrol Unit yang harus digunakan dengan konstanta preprocessor. Jika Anda
mengatur yang CELSIUS konstan dalam baris pertama, aplikasi output suhu
dalam derajat Celcius.
92
19 hanya jika CELSIUS konstan belum ditetapkan. Upload sketsa, dan itu akan
menampilkan suhu saat ini ke port serial setiap lima detik. Outputnya terlihat
sebagai berikut :
27.15C
26.66C
27.15C
Yang kita butuhkan sekarang adalah sebuah program yang berjalan pada
PC Anda yang membaca ini output dan tweet pesan segera karena suhu lebih
besar dari 32 derajat Celcius ( 90 derajat Fahrenheit ). Kita bisa menggunakan
bahasa pemrograman yang mampu membaca dari port serial dan yang mendukung
Twitter, tetapi karena kita telah menggunakan Processing dalam semua lainnya
contoh, kita akan menggunakannya untuk proyek ini juga.
Sebelum kita mulai coding, kita harus mendaftarkan aplikasi kita di twitter
website untuk mendapatkan akses OAuth token.2 OAuth adalah otentikasi skema
yang memungkinkan aplikasi untuk menggunakan sumber daya aplikasi lain '.
Dalam kasus kita, kita akan memberikan aplikasi kita sendiri hak untuk
memperbarui kita Twitter feed tanpa menggunakan username dan password
Twitter kita. Untuk waktu yang lama, Twitter didukung HTTP Basic
authentication. Layanan otomatis hanya membutuhkan username dan password
untuk meminta atau memperbarui Twitter feed. Tapi seperti Agustus 2010,
Twitter telah menghapus dukungan untuk otentikasi dasar dan sekarang
menggunakan OAuth.
93
berikutnya. Pastikan Anda mengatur jenis aplikasi untuk Client dan tipe akses
standar Membaca & Menulis. Anda dapat mengatur aplikasi nama ke string yang
sewenang-wenang, dan akan muncul pada saluran Twitter Anda setiap kali Anda
menggunakan aplikasi untuk tweet pesan. Jika Anda menetapkan untuk
RescueMeFromWork, misalnya, tweet Anda akan dipublikasikan melalui
RescueMeFromWork.
94
Kita melanjutkan dengan beberapa kode boilerplate:
import processing.serial.*;
final float MAX_WORKING_TEMP = 32.0;
final int LINE_FEED = 10;
final int BAUD_RATE = 9600;
final String CONSUMER_KEY =“<YOUR CONSUMER KEY>";
final String CONSUMER_SECRET =“<YOUR CONSUMER SECRET>";
final String ACCESS_TOKEN =“<YOUR ACCESS TOKEN>";
final String ACCESS_TOKEN_SECRET =“<YOUR ACCESS TOKEN
SECRET>";
Serial arduinoPort;
void setup() {
println(Serial.list());
arduinoPort = new Serial(this, Serial.list()[0], BAUD_RATE);
arduinoPort.bufferUntil(LINE_FEED);
}
void draw() {}
Dalam metode setup (), kita mencetak daftar semua perangkat serial yang
tersedia, dan kita menginisialisasi variabel SerialPort kita dengan hotel pertama
yang kita temukan, berharap bahwa itu adalah Arduino. Anda bisa loop melalui
daftar secara otomatis dan mencari sesuatu yang terlihat seperti nama port
Arduino, tapi itu akan menjadi rapuh, juga. Kita tidak memerlukan output grafis
95
untuk aplikasi kita, sehingga metode draw () masih kosong. Sekarang mari kita
menerapkan logika bisnis yang sebenarnya dari kita”Bawa saya ke beach”alarm :
println(temperature);
int sleepTime = 5 * 60 * 1000;
if (temperature > MAX_WORKING_TEMP) {
tweetAlarm();
sleepTime = 120 * 60 * 1000;
}
try{
Thread.sleep(sleepTime);
}
catch(InterruptedException ignoreMe) {}
}
}
}
void tweetAlarm(){
TwitterFactory factory = new TwitterFactory();
Twitter twitter = factory.getInstance();
twitter.setOAuthConsumer(CONSUMER_KEY, CONSUMER_SECRET);
AccessToken accessToken = new AccessToken(
ACCESS_TOKEN,
ACCESS_TOKEN_SECRET
);
96
twitter.setOAuthAccessToken(accessToken);
try{
Status status = twitter.updateStatus(
"Someone, please, take me to the beach!"
);
println(
"Successfully updated status to '“+ status.getText() +”'."
);
}
catch (TwitterException e){
e.printStackTrace();
}
}
97
Kemudian kita mengatur kredensial OAuth memanggil setOAuthAccessToken ( ).
Akhirnya, kita memanggil UpdateStatus ( ). Jika semuanya berjalan dengan baik,
kita mencetak pesan sukses ke konsol. Jika ada yang tidak beres, UpdateStatus ( )
akan memunculkan pengecualian, dan kita mencetak nya jejak stack untuk
keperluan debugging. Itu semua kode yang kita butuhkan, sehingga
menghubungkan Arduino ke PC dan menjalankannya.
98
Arduino mengumumkan
Arduino Ethernet, sebuah papan Arduino yang dilengkapi dengan Ethernet
pelabuhan dan tidak membutuhkan perisai yang terpisah. Hardware hanyalah
salah satu aspek untuk mengubah Arduino ke dalam jaringan perangkat. Kita juga
perlu beberapa perangkat lunak untuk komunikasi jaringan.
Arduino IDE dilengkapi dengan library Ethernet nyaman yang berisi
beberapa kelas yang berhubungan dengan jaringan. Kita akan menggunakannya
sekarang untuk mengakses sebuah DAYTIME
layanan di Internet. Sebuah service9 DAYTIME mengembalikan tanggal dan
waktu sebagai ASCII String. Server DAYTIME mendengarkan pada baik TCP
atau port UDP 13. anda dapat menemukan banyak layanan SIANG di Internet,
salah satunya berjalan di time.nist.gov. Sebelum kita menggunakan layanan
pemrograman dengan Arduino, melihat cara kerjanya menggunakan perintah
telnet:
Trying 192.43.244.18...
Connected to time.nist.gov.
Escape character is '^]'.
55480 10-10-11 13:25:35 28 0 0 138.5 UTC(NIST)*
Connection closed by foreign host.
99
-
- byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
- byte my_ip[] = { 192, 168, 2, 120 };
- byte time_server[] = { 192, 43, 244, 18 }; // time.nist.gov
10
- Client client(time_server, DAYTIME_PORT);
-
- void setup(){
- Ethernet.begin(mac, my_ip);
15 Serial.begin(BAUD_RATE);
-}
-
- void loop(){
- delay(1000);
20 Serial.print("Connecting...");
-
- if (!client.connect()){
- Serial.println("connection failed.");
- } else{
25 Serial.println("connected.");
- delay(1000);
-
- while (client.available()){
- char c = client.read();
30 Serial.print(c);
-}
-
- Serial.println("Disconnecting.");
- client.stop();
35 }
-}
100
Pertama, kita termasuk library Ethernet dan menentukan konstan untuk
Port layanan DAYTIME ( kita juga harus menyertakan library SPI, karena library
Ethernet tergantung padanya ). Kemudian kita mendefinisikan tiga array byte :
101
maik> resolveip time.nist.gov
IP address of time.nist.gov is 192.43.244.18
maik> ping -c 1 time.nist.gov
PING time.nist.gov (192.43.244.18): 56 data bytes
64 bytes from 192.43.244.18: icmp_seq=0 ttl=48 time=173.598 ms
--- time.nist.gov ping statistics ---
1 packets transmitted, 1 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 173.598/173.598/173.598/0.000 ms
Di line 11, kita membuat objek Client baru. Kelas ini merupakan bagian
dari Ethernet library dan memungkinkan kita untuk membuat klien jaringan yang
terhubung ke alamat IP tertentu dan port. Sekarang kita harus menginisialisasi
Ethernet melindungi dirinya sendiri, kita melakukan ini sejalan 14 di setup ()
function. Kita harus memanggil Ethernet.begin (), MAC dan alamat IP. Kemudian
kita menginisialisasi port serial sehingga kita dapat output beberapa pesan debug.
Pada titik ini, kita telah diinisialisasi semua komponen yang kita butuhkan,
jadi kita akhirnya dapat terhubung ke server DAYTIME dan membaca output.
Harap dicatat bahwa Anda juga dapat melewati alamat IP dari gateway jaringan
Anda dan subnet mask untuk Ethernet.begin (). Hal ini diperlukan jika Anda
jangan menghubungkan Arduino langsung ke internet, namun menggunakan
router atau modem kabel sebagai gantinya. Dalam hal ini, Anda dapat melewati
alamat gateway sebagai berikut:
//...
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte my_ip[] = { 192, 168, 2, 120 };
byte time_server[] = { 192, 43, 244, 18 }; // time.nist.gov
// Insert IP address of your cable or DSL router below:
byte gateway[] = { 192, 168, 13, 254 };
Client client(time_server, DAYTIME_PORT);
void setup() {
Ethernet.begin(mac, my_ip, gateway);
102
Serial.begin(BAUD_RATE);
}
//...
Connecting...connected.
55480 10-10-11 13:32:23 28 0 0 579.9 UTC(NIST) *
Disconnecting.
Connecting...connected.
55480 10-10-11 13:32:26 28 0 0 34.5 UTC(NIST) *
Disconnecting.
103
6.6 Emailing dari Command Line
104
maik> nslookup
> set type=mx
> gmail.com
Server: 192.168.2.1
Address: 192.168.2.1#53
Non-authoritative answer:
gmail.com mail exchanger = 5 gmail-smtp-in.l.google.com.
gmail.com mail exchanger = 10 alt1.gmail-smtp-in.l.google.com.
gmail.com mail exchanger = 20 alt2.gmail-smtp-in.
> exit
> exit
Perintah ini mengembalikan daftar semua pertukaran server Google Mail
(MX) yang tersedia pada jaringan Anda. Mengambil nama server pertama, dan
membuka
koneksi ke port standar SMTP 25 (ganti nama server
gmail-smtp-in.l.google.com dan semua alamat email yang sesuai):
105
( to: info@example.com
( subject: This is a test
(
( Really, this is a test!
(.
) 250 2.0.0 OK 1286819789 q43si10820020eeh.100
( QUIT
) 221 2.0.0 closing connection q43si10820020eeh.100
Connection closed by foreign host.
Meskipun cara yang lebih kompleks, sesi ini mirip dengan SIANG kita
contoh. Kita hanya mengirim perintah yang lebih kompleks ( by the way, yang
Anda lakukan tidak perlu menulis perintah dalam huruf besar ). Pertama kita
mengirim HELLO perintah ( ejaan yang benar ) untuk membangun sebuah sesi
dengan SMTP Server. Kemudian kita memberitahu server bahwa kita ingin
mengirim email menggunakan MAIL FROM :
Alamat email yang kita sediakan dengan perintah ini akan digunakan oleh
server dalam kasus email kita memantul kembali. Perhatikan bahwa server
mengirimkan kembali baris respon untuk setiap permintaan. Respon ini selalu
mulai dengan tiga digit kode status.
106
Mengirim perintah QUIT untuk mengakhiri sesi dengan server SMTP. Anda harus
menemukan sebuah email baru di kotak masuk Anda. Jika tidak, coba Server MX
lain pertama. Masih hal yang bisa salah, dan meskipun sederhana dalam teori,
SMTP bisa menjadi binatang yang kompleks dalam praktek.
Seringkali server SMTP kembali membantu pesan kesalahan yang dapat
membantu Anda untuk segera memecahkan masalah Anda. Jangan melanjutkan
sampai Anda telah berhasil dikirim email dari perintah line, karena merupakan
dasar untuk bagian berikutnya di mana Anda akan belajar
cara mengirim email dengan Arduino.
#ifndef __EMAIL__H_
#define __EMAIL__H_
class Email {
String _from, _to, _subject, _body;
public:
Email(
const String& from,
const String& to,
const String& subject,
const String& body
) : _from(from), _to(to), _subject(subject), _body(body) {}
const String& getFrom() const { return _from; }
107
const String& getTo() const { return _to; }
const String& getSubject() const { return _subject; }
const String& getBody() const { return _body;}
};
#endif
108
15 }
-}
-
- void send_line(Client& client, String line){
- const unsigned int MAX_LINE = 256;
20 char buffer[MAX_LINE];
- line.toCharArray(buffer, MAX_LINE);
- Serial.println(buffer);
- client.println(buffer);
- read_response(client);
25 }
-
- public:
-
- SmtpService(
30 byte* smtp_server,
- const unsigned int port) : _smtp_server(smtp_server),
- _port(port) {}
-
- void send_email(const Email& email){
35 Client client(_smtp_server, _port);
- Serial.print("Connecting...");
-
- if (!client.connect()){
- Serial.println("connection failed.");
40 } else{
- Serial.println("connected.");
- read_response(client);
- send_line(client, String("helo"));
- send_line(
45 client,
- String("mail from: <") + email.getFrom() + String(">")
109
- );
- send_line(
- client,
50 String("rcpt to: <") + email.getTo() + String(">")
- );
- send_line(client, String("data"));
- send_line(client, String("from:”) + email.getFrom());
- send_line(client, String("to:”) + email.getTo());
55 send_line(client, String("subject:”) + email.getSubject());
Harus diakui, ini adalah banyak kode, tapi itu sangat sederhana. Pertama,
SmtpService yang kelas merangkum alamat IP SMTP server dan port -nya.
Untuk berkomunikasi dengan server SMTP, kita harus membaca responnya, dan
kita melakukan itu menggunakan read_response swasta ( ) metode mulai baris 10.
Ini menunggu selama empat detik ( server SMTP biasanya sangat sibuk, karena
mereka harus mengirim banyak spam ), dan kemudian membaca semua data
dikirim kembali oleh server dan output ke port serial untuk debugging
tujuan.
Sebelum kita dapat memproses tanggapan, kita harus mengirim
permintaan. send_line ( ) dimulai pada baris 18 mengirimkan satu perintah ke
server SMTP. Anda harus melewati koneksi ke server sebagai contoh Client, dan
baris Anda ingin mengirim harus menjadi obyek String. Untuk mengirim data
yang tersimpan dalam sebuah objek String, kita perlu mengakses karakter
Data mengacu pada. Pada saat penulisan ini, referensi Arduino dokumentasi
memberitahu Anda untuk hanya menggunakan toCharArray ( ) atau getBytes ()
untuk mengambil informasi ini.
Sayangnya, dokumentasi yang salah.
Artinya, kedua metode ini tidak mengembalikan sebuah pointer. Sebaliknya,
mereka mengharapkan Anda untuk memberikan array char cukup besar dan
ukurannya. Itu sebabnya kita konten copy baris untuk penyangga sebelum output
kita ke serial dan Ethernet pelabuhan. Setelah kita telah mengirim data, kita
membaca respon server dan mencetaknya ke port serial. Dalam antarmuka publik,
110
Anda tidak menemukan kejutan. Konstruktor mengharapkan alamat IP SMTP
server dan port -nya. Send_email The ( ) Metode adalah bagian terbesar dari kode
di kelas kita, tapi itu juga salah satu yang sederhana. Ini meniru persis sesi telnet
kita, dan satu-satunya hal yang layak disebutkan adalah penanganan string : kita
menggunakan new class String Arduino itu, dan menggunakan operator
concatenation nya ( + ), kita mengubah setiap string menjadi
Object String.
Mari kita gunakan kelas kita sekarang untuk benar-benar mengirim email :
111
-”Yet another subject",
-”Yet another body"
25 );
- smtp_service.send_email(email);
-}
-
- void loop() {}
112
Sensor Parallax PIR16 adalah contoh yang baik dari alat tersebut, dan kita
akan menggunakannya sebagai dasar alarm pencuri kita. Sensor PIR memiliki tiga
pin : kekuasaan, tanah, dan sinyal. Menghubungkan listrik ke Arduino yang 5V
pasokan, tanah untuk salah satu GND Arduino ini pin, dan sinyal untuk pin digital
2. Sensor ini juga memiliki jumper yang dapat Anda gunakan untuk mengubah
perilakunya. Untuk proyek kita, itu harus dalam posisi H ; yaitu, jumper harus
menutupi pin di sebelah H.
113
-}
-
25 void loop(){
- if (pir.motion_detected()){
- Serial.println("Motion detected");
- } else{
- Serial.println("No motion detected");
30 }
- delay(200);
-}
114
6.9 Menyatukan Semuanya
115
-{
-}
30
- void check(){
- Serial.println("Checking");
- if (_pir_sensor.motion_detected()){
- Serial.println("Intruder detected!");
35 send_alarm();
-}
-}
- };
-
40 #endif
#include <SPI.h>
#include <Ethernet.h>
#include”burglar_alarm.h"
const unsigned int PIR_INPUT_PIN = 2;
const unsigned int SMTP_PORT = 25;
const unsigned int BAUD_RATE = 9600;
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
116
byte my_ip[] = { 192, 168, 2, 120 };
// Insert IP of your SMTP server below!
byte smtp_server[] = { 0, 0, 0, 0 };
PassiveInfraredSensor pir_sensor(PIR_INPUT_PIN);
SmtpService smtp_service(smtp_server, SMTP_PORT);
BurglarAlarm burglar_alarm(pir_sensor, smtp_service);
void setup(){
Ethernet.begin(mac, my_ip);
Serial.begin(BAUD_RATE);
delay(20 * 1000);
}
void loop() {
burglar_alarm.check();
delay(3000);
}
Pertama kita mendefinisikan semua library yang kita butuhkan, dan kita
mendefinisikan konstanta untuk PIR sensor pin dan alamat MAC kita. Kemudian
kita mendefinisikan SmtpService dan PassiveInfraredSensor benda dan
menggunakannya untuk mendefinisikan sebuah BurglarAlarm misalnya.
Dalam metode setup (), kita mendefinisikan port serial dan perisai
Ethernet. Saya juga telah menambahkan penundaan dua puluh detik, yang
memberikan Anda cukup waktu untuk meninggalkan ruangan sebelum alarm
mulai bekerja. Loop ( ) fungsi sederhana, juga. Ini delegasi semua pekerjaan ke
Burglar Kita sudah rapi menyembunyikan kompleksitas kedua email dan
sensor PIR di dua kelas kecil. Untuk membangun alarm pencuri, kita kemudian
hanya harus menulis beberapa kode lem.
Satu kata mengenai privasi : tidak menyalahgunakan proyek dalam bab ini
untuk mengamati orang lain tanpa sepengetahuan mereka. Tidak hanya itu tidak
etis, tetapi di banyak negara bahkan adalah ilegal!
Dalam bab ini, Anda belajar cara yang berbeda untuk menghubungkan
Arduino ke Internet. Beberapa dari mereka membutuhkan PC tambahan,
117
sementara yang lain perlu perisai Ethernet, tetapi mereka semua membuka pintu
untuk berbagai baru dari aplikasi komputasi embedded. Networking adalah salah
satu teknik yang mungkin memiliki dampak langsung
pada dunia luar. Dalam bab berikutnya, Anda akan belajar tentang yang lain
teknik yang memiliki efek yang serupa, Anda akan belajar bagaimana untuk
mengontrol perangkat
jarak jauh.
Jaringan adalah sesuatu yang kompleks dan rumit, dan banyak hal bisa
salah ketika mencoba contoh dalam bab ini. Yang paling umum
masalah adalah sebagai berikut :
• Anda telah memilih port serial yang salah dalam aplikasi Processing.
Secara default, aplikasi menggunakan port serial pertama dapat
menemukan. Mungkin saja Anda telah menghubungkan Arduino Anda yang lain
pelabuhan. Dalam hal ini, Anda harus mengubah indeks 0 dalam pernyataan
arduinoPort = new Serial ( ini, Serial.list ( ) [ 0 ], BAUD_RATE ) ; sesuai.
• Anda lupa pasang kabel Ethernet ke dalam perisai Ethernet.
• jaringan router Anda memiliki daftar putih MAC yang memungkinkan tertentu
saja Alamat MAC untuk mengakses jaringan. Pastikan bahwa alamat MAC Anda
gunakan dalam sketsa Anda masuk daftar putih. Periksa Anda dokumentasi router.
• Anda telah menggunakan alamat MAC yang sama dua kali pada jaringan Anda.
• Anda telah menggunakan alamat IP yang tidak diperbolehkan dalam jaringan
Anda atau yang digunakan sudah oleh perangkat lain. Periksa kembali IP Anda
alamat.
• Anda telah menggunakan perintah yang salah untuk mengakses layanan seperti
Twitter. Pastikan Anda menggunakan token OAuth yang tepat.
• Twitter tidak memungkinkan duplikat tweet. Jadi, setiap kali aplikasi Anda
gagal men-tweet pesan, pastikan Anda tidak tweeted itu
118
baru-baru ini.
• Networks telah menjadi sangat handal selama dekade terakhir, namun
kadang-kadang mereka masih agak rapuh. Jadi, mungkin saja bahwa koneksi
gagal atau bahwa Anda mengalami timeout. Meningkatkan keterlambatan
sketsa yang sesuai.
6.11 Latihan
119
Daftar Pustaka
Website :
http://arduino.cc
http://fritzing.org/
http://arduino.cc/blog/2010/01/01/uno-punto-zero/
http://code.google.com/p/arduino/issues/list?q=milestone=1.0
http://processing.org
http://www.pragprog.com/titles/msard/errata
http://flickr.com
http://makershed.com
http://adafruit.com
http://radioshack.com
http://digikey.com
http://sparkfun.com
http://mouser.com
http://www.analog.com/en/sensors/digital-temperature-
sensors/tmp36/products/product.html
http://arduino.cc/en/uploads/Main/arduino-uno-schematic.pdf
http://arduino.cc/en/Main/Boards
http://arduino.cc/en/Main/ArduinoBoardLilyPad
cxx
Buku :
Paul Butcher. Debug It!: Find, Repair, and Prevent Bugs in
Your Code. The Pragmatic Programmers, LLC, Raleigh, NC,
and Dallas, TX, 2009.
cxxi
Lampiran
Nama Lengkap : Muhammad Bangun Agung
NIM : 202136575862733
Nama Dosen : Onno W. Purbo
Kampus : Surya Unversity
cxxii