Professional Documents
Culture Documents
M.BANGUN
AGUNG
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.
Saya menyadari akan masih banyaknya kekurangan yang terdapat pada
buku ini. Buku ini adalah buku pertama yang saya tulis, jadi saya meminta para
pembaca agar dapat memaklumi segala kesalahan yang terdapat pada buku ini.
Apabila ada kata-kata yang menyinggung perasaan pembaca, saya mohon maaf
yang sebesar-besarnya.
Dengan ini saya mempersembahkan buku pertama saya. Semoga buku ini
bisa bermanfaat bagi saya dan para pembaca.
Daftar Isi
Kata Pengantar ......................................................................................................... i
Daftar Isi ................................................................................................................. ii
Pendahuluan ............................................................................................................ 1
Bab 1 Mengenal Arduino ........................................................................................ 2
1.1 Apakah Arduino itu? ......................................................................................... 3
1.2 Yang Anda butuhkan ........................................................................................ 5
1.3 Instalasi Arduino IDE ....................................................................................... 8
Instalasi Arduino IDE pada Windows ................................................................. 9
Instalasi Arduino IDE pada Mac OS X ............................................................... 9
Instalasi Arduino IDE di Linux ......................................................................... 10
1.4 Arduino IDE .................................................................................................... 10
1.5 Tipe-tipe Data dalam Arduino ........................................................................ 13
1.6 Kompilasi dan Program Uploading................................................................. 15
1.7 LED ................................................................................................................. 17
1.8 Kesalahan-kesalahan yang Mungkin Terjadi .................................................. 18
1.9 Latihan ............................................................................................................ 19
2.1 Yang Anda Butuhkan ...................................................................................... 20
2.2 Mengelola Proyek dan Sketsa ......................................................................... 21
2.3 Mengubah Preferensi ...................................................................................... 22
2.4 Menggunakan Port Serial ................................................................................ 23
2.5 Kesalahan-kesalahan yang Mungkin Terjadi .................................................. 29
2.6 Latihan ............................................................................................................ 29
Bab 2 Proyek-proyek Arduino .............................................................................. 31
3.1 Yang Anda Butuhkan ...................................................................................... 32
3.2 Breadboards .................................................................................................... 33
3.3 Menggunakan LED pada Breadboard ............................................................. 34
3.4 Dice Binary ..................................................................................................... 35
3.5 Tombol-tombol yang Ada ............................................................................... 38
3.6 Menambahkan Tombol ................................................................................... 43
3.7 Membuat Permainan Dadu.............................................................................. 45
ii
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.
Arduino memungkinkan kita untuk mengembangkan proyek elektronik
mulai dari prototipe hingga peralatan-peralatan canggih. Lewatlah sudah hari-hari
ketika Anda harus belajar banyak teori tentang elektronik dan bahasa
pemrograman misterius sebelum Anda bahkan bisa membuat sebuah LED
berkedip. Anda dapat membuat proyek Arduino pertama Anda dalam beberapa
menit tanpa perlu kerja kursus teknik listrik canggih.
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.
Bab 1
Mengenal Arduino
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?
Pada prinsipnya, komputasi biasa adalah bagian dari komputasi fisik.
Keyboard dan mouse adalah sensor untuk input dari dunia nyata, dan display
(seperti monitor dan speaker) atau printer adalah aktuator yang membuat sesuatu
dari dunia maya menjadi nyata. Tapi mengendalikan sensor khusus dan aktuator
menggunakan komputer biasa sangatlah sulit. Jika menggunakan Arduino, hal
tersebut akan menjadi sangat mudah.
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.
Para pemula sering bingung ketika mereka menemukan proyek
Arduino.Bila mencari Arduino, mereka sering menemukan nama-nama aneh
seperti Uno, Duemilanove, Diecimila, LilyPad, atau Seeduino. Masalahnya adalah
bahwa Arduino bukanlah satu barang saja.
Beberapa tahun yang lalu tim Arduino merancang sebuah papan
mikrokontroler merilisnya di bawah secara open source. Anda bisa membeli
papan-papan elektronik yang telah dirakit sepnuhnya di beberapa toko-toko
elektronik, namun orang-orang juga bisa mendownload skematiknya dan
merancang sendiri papan tersebut.
Selama bertahun-tahun tim Arduino meningkatkan desain papan dan
merilis beberapa versi baru. Mereka biasanya memiliki nama-nama Italia seperti
Uno, Duemilanove, atau Diecimila, dan Anda dapat menemukan daftar semua
papan yang pernah diciptakan oleh tim Arduino. Lihat gambar 1.1.
Jumper
(khusus untuk
beberapa
jenis Arduino)
Mikrokontroler
Power Plug
Power Supply
Pada bagian kanan bawah papan, ada enam pin input analog A0 - A5.
Anda dapat menggunakannya untuk menghubungkan sensor analog ke Arduino.
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.
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).
10
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.
Verify
Stop
New
Open
Save
Upload
Serial Monitor
11
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.
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.
Array menyimpan nilai yang memiliki tipe data yang sama:
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
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
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 sepertiSerial port sudah
digunakanketika meng-upload sketsa, periksa apakah Anda telah memilih hak
port serial dari menu Tools> Serial Port. Jika Anda mendapatkan pesan
sepertiupload erroratauprogram 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
20
21
Sketsa Folder item menu. IDE menggunakan direktori tidak hanya untuk
mengatur proyek.
Preferensi juga menyimpan beberapa hal menarik dalam folder berikut :
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.
23
menekan 1, dan itu harus berubah off ketika Anda menekan 2. Berikut semua
kode yang kita butuhkan :
Line 1 const unsigned int LED_PIN = 13;
- const unsigned int BAUD_RATE = 9600;
- void setup(){
5 pinMode(LED_PIN, OUTPUT);
- Serial.begin(BAUD_RATE);
-}
- void loop(){
10 if (Serial.available() > 0){
- int command = Serial.read();
- if (command == '1'){
- digitalWrite(LED_PIN, HIGH);
- Serial.println("LED on");
15 } else if (command == '2'){
- digitalWrite(LED_PIN, LOW);
- Serial.println("LED off");
- } else{
- Serial.print("Unknown command:);
20 Serial.println(command);
-}
-}
-}
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 pesanLED padamelalui 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.
Kompilasi, meng-upload ke Arduino Anda, dan kemudian beralih ke
monitor serial (opsional Anda dapat memasang LED ke pin 13, jika tidak, Anda
hanya dapat mengontrol Arduino Status LED). Pada pandangan pertama, tidak
ada yang terjadi. Itu karena kita belum mengirim perintah ke Arduino belum.
Masukkan 1 dalam kotak teks, dan kemudian klik tombol Kirim. Dua hal yang
harus terjadi sekarang : LED diaktifkan, dan pesanLED padamuncul dalam
serial memonitor window. Kita mengendalikan LED menggunakan keyboard
komputer kita! Bermain-main sedikit dengan perintah 1 dan 2, dan juga
mengamati apa yang terjadi ketika Anda mengirim perintah yang tidak diketahui.
Jika Anda mengetikkan huruf A, misalnya, Arduino akan mengirim kembali
pesanUnknown command :. 65Jumlah 65 adalah kode ASCII dari huruf A, dan
Arduino output data yang masuk ke dalam bentuk yang paling dasar.
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);
Outputnya akan seperti ini :
Unknown command: 65
41
101
1000001
A
Tergantung pada format specifier, Serial.println () secara otomatis
mengkonversi byte ke dalam representasi lain. Desember output byte sebagai
desimal nomor, HEX sebagai angka heksadesimal, dan sebagainya. Perhatikan
bahwa seperti operasi biasanya mengubah panjang data yang akan ditransmisikan.
Representasi biner dari byte tunggal 65, misalnya, membutuhkan 7 byte,
karena mengandung tujuh karakter. penomoran Sistem Ini kecelakaan evolusi
yang 10 adalah dasar untuk penomoran kita sistem. Jika kita hanya memiliki
empat jari pada setiap tangan, itu akan mungkin delapan, dan kita mungkin telah
menemukan komputer beberapa abad sebelumnya. Selama ribuan tahun, orang
telah menggunakan sistem nomor denominasi, dan kita mewakili nomor seperti
4711 sebagai berikut : 4 103 + 7 102 + 1 101 + 1 100 Hal ini membuat
operasi aritmatika yang sangat nyaman.
Tapi ketika bekerja dengan komputer yang hanya menafsirkan bilangan
biner, hal ini sering menguntungkan untuk menggunakan sistem penomoran
berdasarkan angka 2 (biner), 8 (oktal), atau 16 (heksadesimal). Sebagai contoh,
26
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.
Anda dapat mengontrol berbagai perangkat yang menggunakan komunikasi
serial, tetapi Arduino biasa hanya memiliki satu port serial. Jika Anda
membutuhkan lebih, mengambil melihat Arduino mega 2560, yang memiliki
empat seri ports.2
Universal Asynchronous Receiver / Transmitter (UART) 3 perangkat
mendukung komunikasi serial pada Arduino. Perangkat ini menangani
komunikasi serial sedangkan CPU bisa mengurus lainnya tugas. Hal ini sangat
meningkatkan kinerja sistem secara keseluruhan. UART menggunakan pin digital
0 (RX) dan 1 (TX), yang berarti Anda tidak dapat menggunakan mereka untuk
tujuan lain ketika berkomunikasi pada port serial. Jika Anda membutuhkan
mereka, Anda dapat menonaktifkan komunikasi serial menggunakan Serial.end ().
Dengan library SoftwareSerial4, Anda dapat menggunakan pin digital untuk
komunikasi serial. Ini memiliki beberapa keterbatasan serius mengenai kecepatan
dan kehandalan, dan tidak mendukung semua fungsi yang yang tersedia saat
menggunakan port serial biasa.
Dalam bab ini, Anda melihat bagaimana berkomunikasi dengan Arduino
menggunakan port serial, yang membuka pintu ke dunia baru seluruh fisik proyek
komputasi. Dalam bab-bab berikutnya, Anda akan belajar bagaimana
mengumpulkan fakta menarik tentang dunia nyata menggunakan sensor, dan
Anda akan belajar bagaimana mengubah nyata dunia dengan benda bergerak.
Komunikasi serial adalah dasar untuk membiarkan Anda mengontrol semua
tindakan ini menggunakan Arduino dan PC Anda.
28
2.6 Latihan
Tambahkan perintah baru untuk program sampel. Sebagai contoh, perintah 3
bisa membuat LED berkedip untuk sementara waktu.
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 proyekproyek 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.
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
Menghubungkan bagian seperti LED langsung ke Arduino hanya sebuah
pilihan dalam kasus yang paling sepele. Biasanya, Anda akan prototipe proyek
Anda pada papan tempat breadboard yang Anda terhubung ke Arduino. Sebuah
papan tempat breadboardmengemulasipapan sirkuit. Anda tidak harus solder
bagian untuk papan, melainkan,Anda hanya dapat plug mereka ke dalamnya.
Breadboards datang dalam berbagai jenis dan ukuran, tetapi mereka semua
bekerja dengan cara yang sama.
Mereka memiliki banyak soket yang dapat Anda gunakan untuk
menghubungkannya melalui lubang bagian atau kawat. Itu saja tidak akan
menjadi masalah besar, tapi soket yang terhubung dalam cara khusus. Pada
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.
Breadboards datang dalam berbagai jenis dan Anda dapat melihat dua dari
mereka), tetapi mereka semua bekerja dengan cara yang sama. Mereka memiliki
banyak soket yang dapat Anda gunakan untuk menghubungkannya melalui lubang
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
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.
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, kadangkadang 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
#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
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.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
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 katakata 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>
#includetelegraph.h"
char* LETTERS[] = {
".-",-...",-.-.",-..",.", // A-E
"..-.",--.",....",..",.---", // F-J
"-.-",.-..",--",-.",---", // K-O
".--.",--.-",.-.",...",-", // P-T
55
"..-",...-",.--",-..-",-.--", // U-Y
"--..//Z
};
char* DIGITS[] ={
"-----",.----",..---",...--", // 0-3
"....-",.....",-....",--...", // 4-7
"---..",----.// 8-9
};
Seperti kebanyakan program C + +, kita impor beberapa library pertama.
karena kita membutuhkan fungsi seperti toupper () kemudian, kita menyertakan
ctype.h. dan kita memiliki untuk memasukkan telegraph.h untuk membuat
deklarasi kelas kita dan yang sesuai fungsi deklarasi yang tersedia. Tapi apa
WProgram.h baik untuk? Sampai sekarang kita belum memikirkan di mana
konstanta seperti TINGGI, LOW, atau OUTPUT berasal. Mereka didefinisikan
dalam beberapa file header yang datang dengan Arduino IDE, dan Anda dapat
menemukan mereka di hardware / direktori core / Arduino IDE. Silahkan lihat
pada WProgram.h, dan kita melihat bahwa itu berisi file dengan nama wiring.h
yang berisi semua konstanta kita telah digunakan sejauh ini dan banyak lagi. Hal
ini juga menyatakan banyak berguna macro dan fungsi yang paling dasar Arduino
itu.
Bila Anda mengedit sketsa biasa, Anda tidak perlu khawatir tentang
termasuk setiap file header standar, karena IDE tidak secara otomatis di belakang
layar. Segera setelah Anda mulai untuk membuat proyek yang lebih kompleks
yang mengandungnyataC + + kode, Anda harus mengatur segala sesuatunya
sendiri. Anda harus secara eksplisit mengimpor semua library yang Anda
butuhkan, bahkan untuk dasar hal-hal seperti konstanta Arduino. Setelah
mengimpor semua file header yang diperlukan, kita mendefinisikan dua array
String bernama LETTERS dan DIGIT. Mereka berisi kode Morse untuk semua
huruf dan angka, dan kita akan menggunakannya di lain waktu untuk
menerjemahkan teks biasa menjadi Morse kode. Sebelum kita melakukan itu, kita
mendefinisikan konstruktor yang bertanggung jawab untuk menciptakan dan
intializing objek Telegraph baru :
56
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, duniaBuat baru sketsa bernama HelloWorld, dan masukkan kode berikut
::
#includetelegraph.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 merestart 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:
#includetelegraph.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
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
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
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 anakanak 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.
Baik proyek-proyek yang menyenangkan dan serius bisa mendapatkan
keuntungan dari accelerometers. kapan bekerja dengan komputer Anda, Anda
pasti memikirkan proyek-proyek seperti pengendali permainan atau perangkat
kontrol input lainnya. Tapi Anda juga dapat menggunakan mereka ketika
berolahraga atau untuk mengontrol labirin marmer kehidupan nyata. Anda juga
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
Ada banyak accelerometers yang berbeda, berbeda terutama dalam jumlah
sumbu spacial mereka mendukung (biasanya dua atau tiga). Kita menggunakan
ADXL335 dari Analog Devices-sangat mudah untuk digunakan dan available.1
luas Pada bagian ini, kita akan menghubungkan ADXL335 ke Arduino dan
menciptakan program demo kecil yang menunjukkan data mentah sensor
memberikan. di saat itu, kita akan memiliki cepat melihat spesifikasi sensor dan
menafsirkan data.
69
Sensor adalah sirkuit terpadu (IC), dan sisanya hanya pembawa untuk
memungkinkan koneksi. Di atas, Anda melihat 6 pin 0,1header 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.
ADXL335 merupakan perangkat analog : itu memberikan hasil sebagai
tegangan yang harus dikonversi ke nilai-nilai percepatan. Jadi, X, Y, dan Z
konektor harus terhubung ke tiga analog pin pada Arduino. Kita menghubungkan
Z ke analog pin 0, Y ke analog pin 1, dan X ke analog pin 2. Sekarang kita telah
terhubung ADXL335 ke Arduino, mari kita menggunakannya.
70
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 terusmenerus 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
75
76
#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
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
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
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
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 cetakGame Overpesan 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
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.
88
6.9 Latihan
Buat mouse komputer Anda sendiri dengan menggunakan accelerometer
ADXL335. Ini harus bekerja di udara bebas, dan harus memancarkan arus
percepatan sekitar x-dan y-sumbu. Hal ini juga harus memiliki kiri tombol dan
tombol kanan. Menulis beberapa kode Processing (atau mungkin kode dalam
bahasa pemrograman pilihan Anda?) untuk mengontrol pointer mouse pada layar.
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 dengantelanjangArduino yang tidak memiliki kemampuan
jaringan.
Anda masih dapat melampirkan ke Internet, asalkan Anda
menghubungkannya ke PC. Untuk proyek kedua kita, kita akan memperbaiki
situasi dramatis dengan perisai Ethernet. Sekarang Arduino Anda menjadi
jaringan full-blown perangkat yang langsung dapat mengakses layanan IP seperti
layanan SIANG.
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
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.
Jika Anda menghapus baris pertama atau mengubahnya menjadi baris
komentar, Fahrenheit akan digunakan. Untuk mengubah perilaku aplikasi, kita
menggunakan preprocessor # ifdef direktif. Ia memeriksa apakah preprocessor
konstan tertentu telah mengatur, dan kemudian mengkompilasi kode kondisional.
Dalam kasus kita, itu akan mengkompilasi Celcius - to- Fahrenheit rumus di baris
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.
Untuk mendapatkan token akses OAuth, daftar aplikasi baru di
Bagian pengembang website.4 Twitter Setelah Anda login, klikDaftar
aplikasilink, dan mengisi formulir yang Anda lihat pada, pada halaman
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.
Setelah Anda telah terdaftar aplikasi baru Anda berhasil, pergi ke
halaman pengaturan aplikasi untuk melihat kunci konsumen dan konsumen
rahasia. Anda perlu mereka bersama-sama dengan tanda OAuth dan OAuth Anda
tanda rahasia untuk memungkinkan Anda aplikasi mengubah status Twitter Anda.
Untuk melihat tanda OAuth dan rahasia, ikuti link My Access Token.
Salin kunci konsumen, rahasia konsumen, token akses, dan akses rahasia tanda.
Anda akan membutuhkan mereka di bagian berikutnya ketika kita menciak pesan
menggunakan Processing.
94
95
untuk aplikasi kita, sehingga metode draw () masih kosong. Sekarang mari kita
menerapkan logika bisnis yang sebenarnya dari kitaBawa saya ke beachalarm :
void serialEvent(Serial port) {
final String arduinoData = port.readStringUntil(LINE_FEED);
if (arduinoData!= null) {
final String[] data = split(trim(arduinoData), ' ');
if (data.length == 2 &&
(data[1].equals("C") || data[1].equals("F")))
{
float temperature = float(data[0]);
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
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.
Segera setelah perintah telnet terhubung ke server DAYTIME, itu
mengirimkan kembali waktu saat ini dan date.10 Kemudian layanan menutup
koneksi langsung.
Berikut ini adalah implementasi dari perilaku yang sama persis untuk Arduino
dengan perisai Ethernet:
99
100
101
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
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
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
Mari kita gunakan kelas kita sekarang untuk benar-benar mengirim email :
111
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
-{
-}
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>
#includeburglar_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
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.
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
Pencarian Kita b untuk proyek-proyek Ethernet shield lainnya, dan membangun
di setidaknya satu dari mereka. Sebagai contoh, Anda dapat menemukan chat
klien untuk Arduino.18
Membangun sebuah proyek yang mirip dengan alarm pencuri, tapi
menggunakan jenis lain
dari sensor. Ada ton inspirasi di luar sana di Kita b. 19
Tambahkan cap waktu saat ini untuk email alarm pencuri itu. Dapatkan
timestamp dari layanan SIANG.
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-temperaturesensors/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.
Ira Greenberg. Processing: Creative Coding and Computational
Art. Apress, Berkeley, CA, USA, 2007.
Brian W. Kernighan and Dennis Ritchie. The C Programming
Language. Prentice Hall PTR, Englewood Cliffs, NJ, second
edition, 1998.
Scott Meyers. Effective C++: 50 Specific Ways to Improve Yo ur
Programs and Designs. Addison Wesl ey Longman, Reading,
MA, second edition, 1997.
Chris Pine. Learn to Program. The Pragmatic Programmers,
LLC, Raleigh, NC, and Dallas, TX, 2006.
Charles Platt. Make: Electronics. OReilly Media, Inc.,
Sebastopol, CA, 2010.
Bjarne Stroustrup. The C++ Programming Language. Addison
Wesl ey Longman, Reading, MA, 2000.
cxxi
Lampiran
Nama Lengkap
NIM
Nama Dosen
Kampus
cxxii