ARDUINO BEGINNER

17 Maret 2014
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.
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.6 Latihan ............................................................................................................ 29
Bab 2 Proyek-proyek Arduino .............................................................................. 31
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

3.9 Latihan ............................................................................................................ 50
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.9 Latihan ............................................................................................................ 65
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.9 Latihan ............................................................................................................ 89
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.
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.
Gambar 1.1. Jenis-jenis Arduino.
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 denganduino.Anda dapat
menggunakan setiap tiruan yang sepenuhnya kompatibel dengan Arduino asli
untuk membangun semua proyek di dalam buku ini.
1.2 Yang Anda butuhkan

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.
Pins Digital I/O

Tombol Reset
Konektor USB
Jumper
(khusus untuk
beberapa
jenis Arduino)
Mikrokontroler
Power Plug
Power Supply
Pin Analog Input
Gambar 1.2. Bagian-bagian Arduino (Diecimila).
Untuk menghubungkan Arduino ke komputer Anda, Anda hanya

memerlukan kabel USB. Kemudian Anda dapat menggunakan koneksi USB untuk
berbagai tujuan :
Mengupload software baru pada papan.
Berkomunikasi dengan papan Arduino dari komputer Anda.
Menyalurkan daya ke dalam papan Arduino.
Sebagai perangkat elektronik, Arduino membutuhan daya (power). Salah

satu cara untuk menghubungkan daya dengan papan Arduino adalah dengan
menghubungkannya ke port USB komputer, akan tetapi hal bukan solusi yang
baik dalam beberapa kasus. Beberapa proyek tidak memerlukan komputer untuk
menjalankannya, dan akan terasa berlebihan untuk menyalakan sebuah komputer
dan menggunakan dayanya hanya untuk menyalakan Arduino. Port USB juga
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 ArduinoNG 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.
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.
1.3 Instalasi Arduino IDE

Para pengembang Arduino telah menciptakan sebuah sistem
pengembangan terpadu yang sederhana namun sangat bermanfaat yang disebut
dengan Integrated Development Environment (IDE). IDE dapat dijalankan pada
banyak sistem operasi yang berbeda. Sebelum Anda dapat membuat proyek
pertama Anda, Anda harus menginstalnya terlebih dahulu.
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.
Instalasi Arduino IDE pada Mac OS X

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
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).
Instalasi Arduino IDE di Linux

Prosedur Instalasi pada Linux berbeda-beda untuk setiap distribusinya.
Arduino IDE bekerja dengan baik pada hampir semua versi Linux modern, tapi
proses instalasi sangat berbeda dari distribusi ke distribusi. Anda juga harus
menginstal software tambahan (Java Virtual Machine, misalnya) yang telah
preinstalled pada sistem operasi lain. Sebaiknya Anda memeriksa documentasi
resmi Arduino dan mencari petunjuk untuk sistem pilihan Anda.
1.4 Arduino IDE

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.
Verify
Stop
New
Open
Save
Upload
Gambar 1.4. Toolbar Arduino IDE.
Serial Monitor
11
Meskipun menggunakan IDE sangat mudah, Anda mungkin mengalami

masalah. Dalam kasus tersebut, kita lihat menu Help. Menu Help menunjukkan
banyak sumber daya yang berguna di website Arduino yang menyediakan solusi
cepat tidak hanya untuk semua masalah khas tetapi juga untuk referensi materi
dan tutorial.
Untuk dapat memahami fitur-fitur IDE yang paling penting, kita akan
membuat program sederhana yang membuat dioda pemancar cahaya (LED)
berkedip. LED merupakan sumber cahaya murah dan efisien, dan Arduino sudah
dilengkapi dengan beberapa LED. Satu LED yang berkedip menunjukkan apakah
Arduino saat ini memiliki daya, dan dua LED lainnya berkedip saat data
ditransmisikan atau diterima melalui koneksi serial. Dalam proyek kecil pertama,
Anda akan membuat LED Arduino yang berkedip.
Status LED terhubung ke digital IO pin 13. Pin digital bertindak sebagai
salah satu jenis switch : TINGGI atau RENDAH. Jika diatur ke TINGGI, output
pin diatur ke 5 volt, menyebabkan arus mengalir melalui LED, sehingga LED
menyala. Jika diatur kembali ke LOW, aliran arus berhenti, dan LED akan mati.
Buka IDE, dan masukkan kode berikut di editor :
const unsigned int LED_PIN = 13;

- const unsigned int PAUSE = 500;
- void setup(){
5 pinMode(LED_PIN, OUTPUT);
-}
- void loop(){
- digitalWrite(LED_PIN, HIGH);
10 delay(PAUSE);
- digitalWrite(LED_PIN, LOW);
- delay(PAUSE);
-}
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.
1.5 Tipe-tipe Data dalam 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.
Array menyimpan nilai yang memiliki tipe data yang sama:
int values[2]; // Array dengan dua elemen

int values[0] = 42; // Elemen pertama Array
int values[1] = -42; // Elemen kedua Array
int more_values[] = { 42, -42 };
int first = more_values[0]; // first == 42
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.
Arduino panggilan setup () sekali ketika boot, dan kita menggunakannya

untuk menginisialisasi board Arduino dan semua perangkat keras kita telah
terhubung. Kita menggunakan metode pinMode () untuk mengubah pin menjadi
13 pin output. Ini memastikan pin yang mampu menyediakan arus yang cukup
untuk menerangi sebuah LED. Itu keadaan default dari pin adalah INPUT, dan
kedua INPUT dan OUTPUT adalah konstanta yang telah ditetapkan. Fungsi
bernama wajib loop lain () dimulai pada baris 8. Ini berisi logika utama dari
sebuah program, dan Arduino menyebutnya dalam loop tak terbatas. Logika
utama program kita memiliki untuk menghidupkan LED terhubung ke pin 13
pertama.
Untuk melakukan ini, kita menggunakan digitalWrite () dan
menyebarkannya jumlah pin kita dan TINGGI konstan. Ini berarti pin akan
menampilkan 5 volt sampai pemberitahuan lebih lanjut, dan LED terhubung ke
pin menyala. Program ini kemudian memanggil delay () dan menunggu 500
milidetik melakukan apa-apa. Selama jeda ini, pin 13 tetap dalam keadaan
TINGGI, dan LED terus membakar. LED ini akhirnya dimatikan ketika kita
mengatur pin milik negara kembali ke LOW menggunakan digitalWrite () lagi.
Kita tunggu lagi 500 milidetik, dan kemudian loop () fungsi berakhir. The
Arduino dimulai itu lagi, dan LED berkedip. Pada bagian berikutnya, Anda akan
belajar bagaimana untuk membawa program untuk hidup dan transfer ke Arduino.
1.6 Kompilasi dan Program Uploading

Sebelum Anda mengkompilasi dan meng-upload program ke Arduino,
Anda harus mengkonfigurasi dua hal dalam IDE : jenis Arduino Anda
menggunakan dan port serial Arduino Anda terhubung ke. Mengidentifikasi jenis
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
melampirkannyataLED 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 darifiat lux13 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.
1.8 Kesalahan-kesalahan yang Mungkin Terjadi

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 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
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 proyekproyek besar dengan Arduino IDE.
Biasanya, proyek-proyek besar membutuhkan tidak hanya lebih lunak
tetapi juga lebih hardware - Anda akan jarang menggunakan papan Arduino dalam
isolasi. Sebagai contoh, Anda akan menggunakan sensor lebih banyak daripada
yang Anda bayangkan, dan Anda akan harus mengirimkan data mereka mengukur
kembali ke komputer Anda. untuk pertukaran data dengan Arduino, Anda akan
menggunakan port serial. bab ini menjelaskan segala sesuatu yang perlu Anda
ketahui tentang komunikasi serial.
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.
2.1 Yang Anda Butuhkan

Untuk mencoba contoh bab ini, Anda hanya perlu beberapa hal :
Sebuah papan Arduino seperti Uno, Duemilanove, atau Diecimila
Kabel USB untuk menghubungkan Arduino ke komputer Anda
Sebuah LED (opsional)
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 diamdiam.
Sebagai contoh, Anda mungkin telah memperhatikan bahwa Arduino IDE
menyimpan semua kode yang Anda masukkan secara otomatis. Hal ini untuk
mencegah pemula dari kehilangan data atau kode sengaja (untuk tidak
menyebutkan bahwa bahkan pro kehilangan data dari waktu ke waktu, juga).
Pengorganisasian semua file milik proyek secara otomatis adalah salah
satu fitur yang paling penting dari sebuah IDE. Di bawah tenda, Arduino IDE
menciptakan sebuah direktori untuk setiap proyek baru, dan menyimpan semua
file milik proyek dalam direktori ini. Untuk menambahkan file baru untuk sebuah
proyek, klik tombol tab di sebelah kanan untuk membuka menu pop - up tab, dan
kemudian pilih New Tab. Untuk menambahkan file yang sudah ada, gunakan
Sketch > Add File item menu.
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.
Di menu preferensi, Anda dapat mengubahnya sehingga IDE meminta
Anda untuk memberi nama ketika Anda membuat sketsa baru. Anda dapat
memeriksa apa folder sketsa saat ini dalam menggunakan Sketsa > Tampilkan
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.
2.3 Mengubah Preferensi

Untuk proyek awal Anda, default IDE mungkin cocok, tapi cepat atau
lambat Anda akan ingin mengubah beberapa hal.
Ketika Anda melihat kode :... editor.external.bgcolor = # 168299
preproc.web_colors = true editor.font.macosx = Monaco, polos, 10
sketchbook.auto_clean = true update.check = true build.verbose = true
upload.verbose = true... Sebagian besar khasiat ini mengontrol user interface,
yaitu, mereka mengubah font, warna, dan sebagainya. Tapi mereka juga dapat
mengubah aplikasi perilaku. Sebagai contoh, Anda dapat mengaktifkan output
yang lebih verbose untuk operasi.
IDE mengupdate beberapa nilai-nilai preferensi ' ketika dimatikan. Jadi
sebelum Anda mengubah preferensi apapun secara langsung dalam preferensi. txt,
Anda harus menghentikan Arduino IDE. Sekarang Anda sudah akrab dengan
22
Arduino IDE, mari kita melakukan beberapa program. Kita akan membuat
Arduino berbicara dengan dunia luar.
2.4 Menggunakan Port Serial

Arduino membuat banyak aplikasi yang berdiri sendiri kemungkinan - proyek
yang tidak melibatkan komputer tambahan. Dalam kasus seperti itu Anda perlu
menghubungkan Arduino ke komputer sekali untuk meng-upload perangkat
lunak, dan setelah itu, hanya membutuhkan catu daya. Lebih sering, orang
menggunakan Arduino untuk meningkatkan kemampuan komputer dengan
menggunakan sensor atau dengan memberikan akses ke perangkat keras
tambahan. Biasanya, Anda mengendalikan hardware eksternal melalui port serial,
sehingga merupakan ide yang baik untuk belajar bagaimana berkomunikasi secara
serial dengan Arduino.
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 dariserial- 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 :
Line 1 const unsigned int LED_PIN = 13;
- const unsigned int BAUD_RATE = 9600;
- void setup(){
- 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);
-}
-}
-}
Seperti pada contoh sebelumnya, kita mendefinisikan sebuah konstanta

untuk pin LED terhubung ke dan set ke modus OUTPUT di setup () function. di
line 6, kita menginisialisasi port serial menggunakan mulai () fungsi dari Serial
kelas, melewati baud rate 9600 (Anda dapat mempelajari apa baud rate dalam
Bagian C.1, Belajar More About Serial Komunikasi, pada halaman 251). Itu saja
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
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.
Menggunakan Berbeda Serial Terminal Untuk aplikasi sepele, memantau
serial IDE adalah cukup, tetapi Anda tidak dapat dengan mudah dikombinasikan
dengan aplikasi lain, dan tidak memiliki beberapa fitur (misalnya, tidak bisa
mengirim karakter baris baru di IDE yang lebih tua versi). Itu berarti Anda harus
memiliki terminal serial alternatif untuk mengirim data, dan Anda dapat
menemukan banyak dari mereka untuk setiap sistem operasi. Serial Terminal
untuk Windows Putty1 adalah pilihan yang sangat baik bagi pengguna Windows.
Ini adalah gratis, dan itu datang sebagai executable yang bahkan tidak perlu
diinstal.
Setelah Anda telah mengkonfigurasi Putty, Anda dapat membuka koneksi
serial ke Arduino. Klik Open, dan Anda akan melihat sebuah jendela terminal
yang kosong. Sekarang tekan 1 dan 2 beberapa kali untuk menghidupkan dan
mematikan LED. pada Serial Terminal untuk Linux dan Mac OS X Linux dan
Mac pengguna dapat menggunakan perintah layar untuk berkomunikasi dengan
Arduino pada port serial. Memeriksa port serial Arduino terhubung ke (misalnya,
dalam menu Tools> Dewan IDE), dan kemudian jalankan perintah seperti ini
(dengan papan yang lebih tua nama port serial mungkin sesuatu seperti /
dev/cu.usbserial-A9007LUY, dan pada Sistem Linux mungkin / dev/ttyUSB1 atau
yang serupa) : $ Screen / dev/cu.usbmodemfa141 9600 Layar mengharapkan
nama port serial dan baud rate yang akan digunakan.
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.
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

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
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.

1. Setengah - ukuran papan tempat breadboard
2. Tiga LED (untuk latihan Anda harus LED tambahan)
3. Dua 10k resistor
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
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.
3.3 Menggunakan LED pada Breadboard

Sampai sekarang, kita menggunakan LED yang dipasang di papan
Arduino, dan kita terhubung satu LED langsung ke Arduino. Pada bagian ini, kita
akan pasang LED ke papan tempat breadboard dan kemudian menghubungkan ke
papan tempat breadboard Arduino. Pada halaman berikut, Anda dapat melihat foto
dari rangkaian final kita. Ini terdiri dari sebuah Arduino, papan tempat
breadboard, LED, tiga kabel, dan 1k resistor (lebih pada bagian dalam beberapa
menit). Hubungkan Arduino ke papan tempat breadboard dengan menggunakan
dua kabel. Hubungkan pin 12 dengan kolom kesembilan dari papan tempat
breadboard, dan menghubungkan pin tanah dengan kesepuluh kolom. Ini secara
otomatis menghubungkan semua soket di kolom 9 sampai 12 pin dan semua soket
dalam kolom 10 ke tanah.
Pilihan ini kolom adalah sewenang-wenang, dan Anda bisa menggunakan
kolom lain sebagai gantinya. Pasang konektor negatif LED (yang lebih pendek) ke
dalam kolom 10 dan konektor positif ke dalam kolom 9. Bila Anda pasang di
bagian atau kawat ke papan tempat breadboard, Anda harus menekan mereka
dengan kuat sampai mereka tergelincir masuk Anda mungkin membutuhkan lebih
dari satu kali coba, terutama pada papan baru, dan sering sangat berguna untuk
mempersingkat konektor sebelum memasukkan mereka ke dalam papan tempat
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.
3.4 Dice Binary

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 :
const unsigned int LED_BIT0 = 12;

- const unsigned int LED_BIT1 = 11;
5 void setup(){
- pinMode(LED_BIT0, OUTPUT);
10 randomSeed(analogRead(A0));
- long result = random(1, 7);
- output_result(result);
-}
15 void loop(){
-}
- void output_result(const long result){
- digitalWrite(LED_BIT0, result & B001);
20 digitalWrite(LED_BIT1, result & B010);
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.
Kompilasi kode, meng-upload ke Arduino, dan bermain sedikit dengan

Anda dadu biner. Anda telah menguasai proyek elektronik canggih pertama Anda!
Nikmati sejenak! Jadi, setiap kali Anda ingin melihat hasil yang baru, Anda harus
me-reset Arduino. Itu mungkin antarmuka pengguna yang paling pragmatis Anda
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.
3.5 Tombol-tombol yang Ada

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.
const unsigned int BUTTON_PIN = 7;

void setup() {
pinMode(LED_PIN, OUTPUT);
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);
}
Kita menghubungkan tombol ke pin 7 dan LED untuk pin 13 dan

menginisialisasi pin sesuai pada setup () function. Dalam loop (), kita membaca
saat ini keadaan pin yang terhubung ke tombol. Jika TINGGI, kita beralih LED
on. Jika tidak, kita mematikannya. Meng-upload program ke Arduino, dan Anda
akan melihat bahwa LED adalah pada selama Anda menekan tombol. Segera
setelah Anda melepaskan tombol, LED akan mati.
Ini sangat keren, karena sekarang kita hampir memiliki semua yang kita
butuhkan untuk mengendalikan dadu kita menggunakan tombol kita sendiri. tapi
sebelum kita lanjutkan, kita akan sedikit meningkatkan contoh kita dan
mengubah tombol menjadi tombol lampu nyata. Untuk membangun sebuah
lampu, kita mulai dengan solusi yang paling sederhana mungkin. Jangan
mengubah arus hubung, dan meng-upload program berikut untuk Arduino Anda :

- const unsigned int LED_PIN = 13;
- void setup(){
- pinMode(BUTTON_PIN, INPUT);
-}
- int led_state = 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 :

void setup() {
pinMode(LED_PIN, OUTPUT);
}
int old_button_state = LOW;
int led_state = LOW;
void loop() {
const int CURRENT_BUTTON_STATE = digitalRead(BUTTON_PIN);
if (CURRENT_BUTTON_STATE!= old_button_state &&
CURRENT_BUTTON_STATE == HIGH)
{
led_state = (led_state == LOW) ? HIGH : LOW;
digitalWrite(LED_PIN, led_state);
}
old_button_state = CURRENT_BUTTON_STATE;
}
Setelah inisialisasi tombol dan pin LED, kita mendeklarasikan dua

variabel sekarang: toko old_button_state keadaan sebelumnya tombol tekan kita,
dan led_state menyimpan negara LED saat ini. Keduanya dapat berupa TINGGI
atau RENDAH. Dalam loop () fungsi, kita masih harus membaca tombol negara
saat ini, tapi sekarang kita tidak hanya memeriksa apakah TINGGI. Kita juga
memeriksa apakah itu telah berubah sejak terakhir kali kita membacanya. Hanya
ketika kedua kondisi terpenuhi kita beralih negara LED. Jadi, kita tidak lagi
menyalakan LED dan mematikan berulang-ulang selama tombol ditekan.
Di akhir program kita, kita harus menyimpan kondisi tombol saat di
old_button_state. Upload versi baru kita, dan Anda akan melihat bahwa solusi 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:

- const unsigned int LED_PIN = 13;
- void setup(){
- pinMode(BUTTON_PIN, INPUT);
-}
- int old_button_state = LOW;
10 int led_state = LOW;
- void loop(){
- if (CURRENT_BUTTON_STATE!= old_button_state &&
15 CURRENT_BUTTON_STATE == HIGH)
-{
- led_state = (led_state == LOW) ? HIGH : LOW;
- delay(50);
20 }
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.
3.6 Menambahkan Tombol

Sampai sekarang, kita harus penyalahgunaan tombol reset Arduino untuk
mengontrol dadu. Solusi ini jauh dari optimal, jadi kita akan menambahkan
tombol kita sendiri. Kita perlu mengubah kita saat ini sirkuit hanya sedikit.
Sebenarnya, kita tidak perlu mengubah yang sudah ada bagian sama sekali, kita
hanya perlu menambahkan beberapa hal. Pertama kita pasang tombol ke papan
tempat breadboard dan menghubungkannya ke pin 7.
Kemudian kita menghubungkan tombol ke tanah melalui sebuah 10k
resistor dan menggunakan sepotong kecil kawat menghubungkannya ke 5 volt
pin. Itu semua hardware yang kita butuhkan. Berikut perangkat lunak yang
sesuai:

void setup() {
pinMode(LED_BIT0, OUTPUT);
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);
}
- void loop(){
- if (CURRENT_BUTTON_STATE!= old_button_state &&
15 CURRENT_BUTTON_STATE == HIGH)
-{
- led_state = (led_state == LOW) ? HIGH : LOW;
- 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.
3.7 Membuat Permainan Dadu

Menghidupkan dadu dasar kita menjadi sebuah permainan full-blown
membutuhkan penambahan tombol tekan yang lain. Dengan yang pertama kita
masih bisa melempar dadu, dan dengan yang kedua kita dapat memprogram
menebak. Ketika kita melempar dadu lagi dan hasil saat ini sama dengan menebak
kita, tiga LED pada mati akan berkedip. Jika tidak, mereka akan tetap gelap.
Untuk memasukkan menebak, tekan tombol menebak nomor yang benar kali. Jika
Anda pikir hasil selanjutnya akan menjadi 3, misalnya, tekan menebak tombol
tiga kali dan kemudian tekan tombol start. Untuk menambahkan tombol lain ke
sirkuit, melakukan hal yang sama seperti untuk yang pertama. Anda dapat melihat
bahwa kita memiliki ditambahkan lagi rangkaian tombol lain untuk papan tempat
breadboard. Kali ini kita sudah terhubung ke pin 5.
Sekarang kita perlu beberapa kode untuk mengontrol tombol baru, dan
Anda mungkin tergoda untuk menyalin dari program terakhir kita. Setelah semua,
kita disalin hardware desain juga, kan? Dalam dunia nyata, beberapa redundansi
benar-benar diterima, karena kita benar-benar membutuhkan dua tombol fisik,
bahkan jika mereka pada prinsipnya sama. Dalam dunia perangkat lunak,
redundansi adalah Nogo a, jadi kita tidak akan menyalin logika menghilangkan
bounce kita tapi menggunakan library1 yang ditulis untuk tujuan ini. Ambil
library, dan ekstrak isinya ke dalam ~ / Documents / Arduino / library (pada Mac)
atau My Documents \ Arduino \ library (pada kotak Windows). Biasanya itu saja
yang harus Anda lakukan, tapi tidak pernah
45
salahnya untuk membaca petunjuk instalasi dan dokumentasi di halaman web.

Berikut versi final dari kode biner dadu kita:
#include <Bounce.h>
5 const unsigned int LED_BIT2 = 10;
- const unsigned int START_BUTTON_PIN = 5;
- const unsigned int GUESS_BUTTON_PIN = 7;
10 void setup(){
- pinMode(START_BUTTON_PIN, INPUT);
15 pinMode(GUESS_BUTTON_PIN, INPUT);
- randomSeed(analogRead(A0));
-}
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){

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

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.

Sebuah papan Arduino seperti Uno, Duemilanove, atau Diecimila
Kabel USB untuk menghubungkan Arduino ke komputer Anda
Sebuah LED
Sebuah speaker atau buzzer (mereka adalah opsional)
4.2 Mempelajari Dasar-dasar dari Kode Morse

Kode Morse diciptakan untuk mengubah teks ke sounds.1 Pada
prinsipnya, bekerja seperti encoding set karakter seperti ASCII. Tapi sementara
ASCII mengkodekan karakter angka, dalam kode Morse mereka urutan titik dan
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!
4.3 Membuat Morse Code Generator

Bagian utama dari library kita akan menjadi C + + kelas bernama
Telegraph. dalam hal ini bagian, kita akan mendefinisikan interface-nya, tapi kita
akan mulai dengan sketsa baru yang terlihat sebagai berikut : Ambil Telegraph /
Telegraph.pde
void setup() {
}
void loop() {
}
Ini adalah program Arduino paling minimalis mungkin. Ia tidak
melakukan apa-apa kecuali mendefinisikan semua fungsi wajib, bahkan jika
mereka kosong. Kita melakukan ini sehingga kita dapat mengkompilasi pekerjaan
kita berlangsung dari waktu ke waktu dan memeriksa apakah ada kesalahan
sintaksis. Simpan sketsa sebagai Telegraph, dan IDE akan membuat folder
bernama Telegraph dan file bernama Telegraph. pde di dalamnya.
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 :
Telegraph telegraph(13, 200);

telegraph.send_message("Hello, world!");
Pada baris pertama, kita membuat Telegraph objek baru yang
berkomunikasi pada pin 13 dan memancarkan dits yang 200 milidetik panjang.
Kemudian kita memancarkan pesanHello, world!sebagai kode Morse. Dengan
cara ini, kita dapat mengirim pesan apapun yang kita inginkan, dan kita dapat
mengubah pin dan panjang dari dit dengan mudah. Sekarang kita telah
mendefinisikan antarmuka, kita akan menerapkannya di akhirat bagian.
4.4 Interface Generator

Mendeklarasikan antarmuka adalah penting, tetapi itu sama pentingnya
untuk mengimplementasikan mereka. Buat tab baru, masukkan nama file
telegraph.cpp, dan kemudian masukkan kode 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
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);
}
Konstruktor mengharapkan dua argumen: jumlah pin yang Kode Morse
harus dikirim ke dan panjang dit yang diukur dalam milidetik. Kemudian
menyimpan nilai-nilai ini dalam sesuai variabel instan, menghitung panjang benar
dah, dan ternyata komunikasi pin ke pin output.
Anda mungkin pernah melihat bahwa semua variabel misalnya swasta
mulai dengan menggarisbawahi. Itu adalah konvensi yang saya suka secara
pribadi. Hal ini tidak diberlakukan oleh C + + atau Arduino IDE.
4.5 Output Simbol Kode Morse

Setelah semuanya telah diinisialisasi, kita dapat mulai keluaran kode
Morse simbol. Kita menggunakan beberapa metode pembantu kecil untuk
membuat kode kita sebagai dibaca mungkin:
void Telegraph::output_code(const char* code) {

for (int i = 0; i < strlen(code); i++){
if (code[i] == '.')OUTPUTTING MORSE CODE SYMBOLS 93
dit();
else
dah();
}
}
void Telegraph::dit() {
Serial.print(".");
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:
Line 1 void Telegraph::send_message(const char* message) {

- for (int i = 0; i < strlen(message); i++){
- const char current_char = toupper(message[i]);
- if (isalpha(current_char)){
5 output_code(LETTERS[current_char - 'A']);
- delay(_dah_length);
- } else if (isdigit(current_char)){
- output_code(DIGITS[current_char - '0']);
- delay(_dah_length);
10 } else if (current_char == ' '){
58
- Serial.print(");
- delay(_dit_length * 7);
-}
-}
15 Serial.println();
-}
send_message () output karakter pesan oleh karakter dalam satu lingkaran.

di baris 3, kita menghidupkan karakter saat ini menjadi huruf besar, huruf kecil
karena karakter yang tidak didefinisikan dalam kode Morse (itulah alasan
mengapa Anda tidak dapat menerapkan chat client menggunakan kode Morse).
Kemudian kita cek apakah karakter saat ini adalah surat menggunakan C isalpha
() function.
Jika itu, kita menggunakannya untuk menentukan representasi kode Morse
-nya yang disimpan di SURAT array. Untuk melakukan itu, kita menggunakan
trik lama : dalam tabel ASCII semua huruf (dan angka) muncul dalam urutan yang
benar, yaitu, A = 65, B = 66, dan seterusnya. Untuk mengubah karakter saat ini
menjadi indeks untuk SURAT array, kita harus mengurangi 65 (atau ' A ') dari
kode ASCII. ketika kita telah menentukan kode Morse yang benar, kita lulus ke
output_symbol () dan menunda program untuk panjang dah sesudahnya.
Algoritma ini bekerja persis sama untuk keluaran digit, kita hanya harus
indeks array DIGIT bukan SURAT array, dan kita memiliki untuk mengurangi
nilai ASCII dari karakter 0. Sejalan 10, kita cek apakah kita menerima karakter
kosong. Jika ya, kita mencetak karakter kosong ke port serial dan menunggu
selama tujuh dits. Semua karakter lain diabaikan : kita hanya huruf proses, angka,
dan kosong. Pada akhir metode, kita mengirim karakter baris baru ke port serial
untuk menandai akhir pesan.
4.6 Memasang dan Menggunakan Class Telegraph
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
::
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);
}
Sketsa ini memancarkan stringHello, world!Sebagai kode Morse setiap

lima detik. Untuk mencapai hal ini, kita menyertakan definisi Tel EGR kelas aph
kita, dan kita mendefinisikan konstanta untuk pin LED kita terhubung ke dan
untuk panjang dits kita. Kemudian kita membuat Tel EGR objek aph global dan
Setup kosong () function. Dalam loop (), maka kita memanggil send_message ()
pada kita Telegraph misalnya setiap lima detik.
Ketika anda mengkompilasi sketsa ini, Arduino IDE secara otomatis
mengkompilasi library telegraf, juga. Jadi jika Anda membuat kesalahan sintaksis
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:
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.
Selanjutnya kita mendefinisikan tiga variabel global : message_text adalah

buffer karakter yang akan diisi dengan data yang kita terima pada port serial.
indeks terus melacak posisi kita saat ini dalam buffer, dan telegraf adalah
Telegraph objek yang akan kita gunakan untuk mengubah pesan
menjadiblinkenlights.3 setup () menginisialisasi port serial, dan dalam lingkaran
() kita memeriksa apakah baru Data telah tiba, memanggil Serial.available ().
Kita membaca byte berikutnya jika baru data tersedia, dan kita memeriksa
apakah karakter linefeed atau apakah itu byte terakhir yang cocok dengan
penyangga karakter kita. dalam kedua kasus, kita mengatur byte terakhir dari
message_text ke 0, karena string dalam C / C + + adalah null- dihentikan.
Kita juga mengatur ulang indeks sehingga kita dapat membaca berikutnya
pesan, dan akhirnya kita mengirim pesan menggunakan telegraf kita. dalam semua
kasus lain, kita menambahkan byte terbaru untuk pesan teks saat ini dan
melanjutkan. Anda harus mengkompilasi dan meng-upload program sekarang.
Buka monitor serial, dan pilihCarriage returndari akhir baris drop-down menu
di bagian bawah jendela. Dengan set pilihan, monitor seri secara otomatis akan
menambahkan karakter baris baru untuk setiap baris mengirimkan ke Arduino.
Masukkan pesan seperti nama Anda, klik Mengirim tombol, dan melihat
bagaimana Arduino mengubahnya menjadi cahaya. Karena kita telah dikemas
seluruh Morse kode logika di Telegraph kelas, program utama kita adalah pendek
dan ringkas. Membuat perangkat lunak untuk perangkat embedded tidak berarti
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.
4.7 Sentuhan Akhir

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 :
# Syntax-coloring for the telegraph library

Telegraph KEYWORD1
send_message KEYWORD2
Baris yang dimulai dengan karakter # mengandung komentar dan akan

diabaikan. Garis yang tersisa berisi nama salah satu anggota library dan jenis
anggota. Pisahkan dengan karakter tab. kelas-kelas memiliki tipe KEYWORD1,
sedangkan fungsi memiliki tipe KEYWORD2. untuk konstanta, gunakan
LITERAL1.
Untuk mengaktifkan pewarnaan sintaks untuk library telegraf, copy
keywords.txt untuk folder library, dan restart IDE. Sekarang nama Telegraph
kelas akan oranye, dan send_message () akan berwarna coklat. Sebelum Anda
akhirnya mempublikasikan library Anda, Anda harus menambahkan beberapa hal:
Menyimpan semua contoh sketsa dalam folder bernama contoh, dan copy ke
folder library.
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 :
maik> zip -r Telegraph Telegraph

maik> tar cfvz Telegraph.tar.gz Telegraph
Perintah pertama menciptakan sebuah file bernama Telegraph.zip, dan

yang kedua satu menciptakan Telegraph.tar.gz. Kedua format yang luas, dan yang
terbaik untuk menawarkan mereka berdua untuk di-download.
Meskipun Anda harus melakukan banyak operasi file manual, itu masih
mudah untuk membuat sebuah library Arduino. Jadi, tidak ada alasan : setiap kali
Anda pikir Anda telah membangun sesuatu yang keren, membuatnya tersedia
untuk publik.
Sampai saat ini proyek-proyek kita telah berkomunikasi dengan dunia luar
menggunakan LED (output) dan tombol tekan (input). Dalam bab berikutnya,
Anda akan belajar bagaimana bekerja dengan perangkat input yang lebih canggih,
seperti ultrasonik sensor. Anda juga akan belajar bagaimana untuk
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 :
void Telegraph::output_symbol(const int length) {

const int frequency = 131;
65
tone(_output_pin, frequency, length);

}
Ini mengirimkan gelombang persegi ke speaker, dan memainkan nada yang

memiliki frekuensi 131 Hertz (menemukanMelodycontoh yang datang
dengan Arduino IDE untuk mempelajari lebih lanjut tentang bermain catatan
dengan speaker piezo).
Meningkatkan desain library untuk membuatnya lebih mudah untuk mendukung
berbagai perangkat output. Sebagai contoh, Anda bisa melewati beberapa jenis
output- Perangkat objek ke Telegraph konstruktor. Kemudian berasal LedDevice
sebuah dan SpeakerDevice dari OutputDevice. Ini bisa terlihat sebagai berikut:
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){
//...
}
};
Anda dapat menggunakan kelas tersebut seperti ini :
66
Led led;
Speaker speaker;
OutputDevice* led_device = &led;
OutputDevice* speaker_device = &speaker;
led_device->output_symbol(200);
speaker_device->output_symbol(200);
Sisanya terserah Anda.
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.

1. Sebuah papan breadboard setengah ukuran atau-bahkan lebih baik-an
Prototyping Arduino perisai dengan papan breadboard kecil
2. Sebuah accelerometer ADXL335
3. Sebuah tombol tekan
4. Resistor A 10k
5. beberapa kabel
8. A 6 pin 0,1header standar
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.
5.3 Menghidupkan Accelerometer

Sebuah strategi pragmatis untuk mendapatkan akrab dengan perangkat
baru untuk menghubungkan itu dan melihat data apa yang memberikan. Program
berikut membaca nilai input untuk semua tiga sumbu dan output mereka ke port
serial:
const unsigned int X_AXIS_PIN = 2;
const unsigned int Y_AXIS_PIN = 1;
const unsigned int Z_AXIS_PIN = 0;
70

void setup(){
}
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:
344 331 390

364 276 352
388 286 287
398 314 286
376 332 289
370 336 301
379 338 281
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:

int min_x, min_y, min_z;
int max_x, max_y, max_z;
void setup() {
min_x = min_y = min_z = 1000;
max_x = max_y = max_z = -1000;
}
void loop() {
const int x = analogRead(X_AXIS_PIN);
const int y = analogRead(Y_AXIS_PIN);
const int z = analogRead(Z_AXIS_PIN);
min_x = min(x, min_x); max_x = max(x, max_x);
min_y = min(y, min_y); max_y = max(y, max_y);
min_z = min(z, min_z); max_z = max(z, max_z);
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(")");
}
Kita mendeklarasikan variabel untuk nilai-nilai minimum dan maksimum

dari ketiga kapak, dan kita menginisialisasi mereka dengan angka yang pasti
keluar dari berbagai sensor (-1000 dan 1000). Dalam loop () fungsi, kita secara
permanen mengukur percepatan semua tiga sumbu dan menyesuaikan minimum
dan nilai maksimum sesuai. Kompilasi dan upload sketsa, kemudian
memindahkan papan breadboard dengan sensor ke segala arah, dan kemudian
miringkan ke segala arah. Pindahkan perlahan-lahan, bergerak cepat, miringkan
perlahan-lahan, dan miring dengan cepat.
Gunakan kabel panjang, dan berhati-hati ketika bergerak dan berputar
papan breadboard sehingga Anda tidak sengaja melonggarkan sambungan.
Setelah beberapa saat nilai-nilai minimum dan maksimum akan menstabilkan, dan
Anda harus mendapatkan output seperti ini : x (247/649), y (253/647), z (278/658)
Tuliskan nilai-nilai ini, karena kita membutuhkannya nanti, dan mungkin Anda
akan membutuhkannya ketika Anda melakukan percobaan sensor sendiri.
Sekarang mari kita lihat bagaimana untuk menyingkirkan jitter. Pada prinsipnya,
itu sederhana. malah kembali data percepatan segera, kita mengumpulkan
73
pembacaan terakhir dan kembali rata-rata mereka. Dengan cara ini, perubahan
kecil akan disetrika out. Kode terlihat sebagai berikut :
Line 1 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;
5 const unsigned int PINS[NUM_AXES] ={
- X_AXIS_PIN, Y_AXIS_PIN, Z_AXIS_PIN
- };
- const unsigned int BUFFER_SIZE = 16;
10
- int buffer[NUM_AXES][BUFFER_SIZE];
- int buffer_pos[NUM_AXES] = { 0 }
- void setup(){
15 Serial.begin(BAUD_RATE);
-}
- int get_axis(const int axis){
- delay(1);
20 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++)
25 sum += buffer[axis][i];
- return round(sum / BUFFER_SIZE);
-}
- int get_x() { return get_axis(0);}
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());
-}
Seperti biasa, kita mendefinisikan beberapa konstanta untuk pin kita

gunakan pertama. Kali ini, kita juga mendefinisikan sebuah konstanta bernama
NUM_AXES yang berisi jumlah sumbu kita mengukur. Kita juga memiliki
sebuah array bernama PIN yang berisi daftar pin kita gunakan. Ini membantu kita
menjaga kode kita lebih generik nanti. Sejalan 11, kita menyatakan buffer untuk
semua sumbu. Mereka akan diisi dengan data sensor kita mengukur, sehingga kita
dapat menghitung nilai rata-rata ketika kita membutuhkannya. Kita harus
menyimpan posisi kita saat ini di setiap buffer, sehingga dalam baris 12, kita
mendefinisikan sebuah array dari posisi penyangga. setup () hanya
menginisialisasi port serial, dan tindakan nyata terjadi di yang get_axis ()
function.
Dimulai dengan penundaan kecil untuk memberikan Arduino beberapa
waktu untuk beralih antara pin analog, jika tidak, Anda mungkin mendapatkan
buruk data. Kemudian membaca percepatan untuk sumbu kita telah berlalu dan
menyimpannya di posisi buffer saat ini milik sumbu. Hal ini meningkatkan posisi
penyangga dan set kembali ke nol saat akhir buffer telah tercapai. Akhirnya, kita
kembali nilai rata-rata dari data yang kita telah dikumpulkan sejauh untuk sumbu
saat ini.
Itulah seluruh trik. Untuk melihat efeknya, meninggalkan sensor tersentuh
pada meja Anda, dan menjalankan program dengan ukuran buffer yang berbeda.
Jika Anda tidak menyentuh sensor, Anda tidak akan mengharapkan output
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.
5.5 Kontroler dan Game

Pengendali Untuk membangun sebuah game controller full-blown, kita
hanya perlu menambahkan tombol untuk papan breadboard kita. (tolong,
doublecheck pin label di papan breakout Anda!).
Itulah bagaimana tampilannya di dalam game controller khas modern. Kita

akan tidak membangun perumahan mewah untuk controller, tapi kita masih harus
berpikir tentang ergonomi sejenak. Solusi papan breadboard kita saat ini adalah
agak rapuh, dan Anda tidak bisa benar-benar gelombang di sekitar papan ketika
itu terhubung ke Arduino.
Cepat atau lambat Anda akan melepas beberapa kabel, dan kontroler akan
berhenti bekerja. Untuk mengatasi masalah ini, Anda bisa mencoba untuk
melampirkan papan breadboard dengan Arduino menggunakan beberapa karet
gelang. Yang bekerja, tetapi tidak terlihat sangat cantik, dan itu masih sulit untuk
menangani.
Sebuah solusi yang jauh lebih baik adalah dengan menggunakan perisai
Arduino Prototyping. Ini adalah papan breadboard pluggable yang memungkinkan
Anda dengan cepat membangun sirkuit prototipe. Papan breadboard ini dikelilingi
oleh pin Arduino itu, sehingga Anda tidak perlu lagi kabel panjang. Shields adalah
cara yang bagus untuk meningkatkan kemampuan Arduino, dan Anda bisa
mendapatkan perisai bagi banyak berbeda tujuan seperti menambahkan Ethernet,
suara, display, dan seterusnya.
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 NUM_AXES = 3;
const unsigned int PINS[NUM_AXES] ={
X_AXIS_PIN, Y_AXIS_PIN, Z_AXIS_PIN
};
const unsigned int BUFFER_SIZE = 16;
int buffer[NUM_AXES][BUFFER_SIZE];
int buffer_pos[NUM_AXES] = { 0 };
Bounce button(BUTTON_PIN, 20);
void setup() {
}
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");
}
Kita menggunakan Bouncing Class untuk menghilangkan bounce tombol.

Sisanya kode ini cukup banyak standar, dan satu-satunya hal yang layak disebut
adalah bahwa kita menggunakan 19200 baud tingkat untuk mentransfer data
pengontrol cukup cepat. Kompilasi dan meng-upload kode, buka terminal serial,
dan bermain-main dengan controller. Pindahkan, tekan tombol kadang-kadang,
dan seharusnya output sesuatu seperti berikut:
324 365 396 0

325 364 397 0
325 364 397 1
325 364 397 0
325 365 397 0
325 365 397 1
326 364 3970
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.
5.6 Membuat Game Sendiri

Untuk menguji pengendali permainan kita, kita akan memprogram
Breakout3 clone sederhana di Processing. Tujuan permainan ini adalah untuk
menghancurkan semua batu bata di bagian atas dari layar dengan bola. Anda dapat
mengontrol bola dengan dayung di bawah layar, dan Anda dapat memiringkan
controller di sekitar sumbu x untuk memindah pemukul horizontal.
Meskipun ini bukan buku tentang pemrograman game, tidak akan sakit
untuk melihat jeroan permainan, terutama karena pemrograman game Pengolahan
dengan benar-benar menyenangkan murni! Ambil kode dari website4 buku dan
main game sebelum Anda menyelam ke dalam kode. Karena kita akan
menghubungkan game controller kita ke port serial, kita memiliki untuk
menginisialisasi:
import processing.serial.*;
Serial arduinoPort;
Kemudian kita mendefinisikan beberapa konstanta yang akan membantu kita

untuk menyesuaikan permainan mudah:
final int COLUMNS = 7;

final int ROWS = 4;
final int BALL_RADIUS = 8;
final int BALL_DIAMETER = BALL_RADIUS * 2;
final int MAX_VELOCITY = 8;
final int PADDLE_WIDTH = 60;
final int PADDLE_HEIGHT = 15;
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;
Sebagian besar nilai-nilai ini harus cukup jelas-mereka menentukan

ukuran dari obyek yang muncul di layar. Sebagai contoh, PADDLE_ WI DT H
adalah lebar dayung diukur dalam pixel, dan KOLOM dan ROWS mengatur tata
letak batu bata. Anda harus mengganti X_AXIS_MIN dan X_AXIS_MAX untuk
mengukur nilai-nilai minimum dan maksimum Anda untuk sensor Anda.
Selanjutnya kita memilih cara untuk mewakili objek permainan :
int px, py;

int vx, vy;
int xpos = WIDTH / 2;
int[][] bricks = new int[COLUMNS][ROWS];
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:
boolean buttonPressed = false;

boolean paused = true;
80
boolean done = true;
Tidak mengherankan, kita menetapkan buttonPressed untuk benar ketika tombol

pada controller ditekan. Jika tidak, itu adalah fal se. dijeda memberitahu Anda
apakah permainan saat ini dihentikan sementara, dan dilakukan adalah benar
ketika tingkat saat ini dilakukan, yaitu, ketika semua batu bata telah hancur.
Setiap program Pengolahan membutuhkan setup () fungsi, dan di sini adalah milik
kita:
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
Setup () fungsi menginisialisasi layar, menyembunyikan pointer mouse dengan

noCursor (), dan menyetel font yang akan kita gunakan untuk pesan keluaran
(membuat font menggunakan Alat Pengolahan s> Buat menu Font). Kemudian
kita sebut initGame () untuk menginisialisasi batu bata array dan posisi bola saat
ini dan kecepatan. Untuk membuat hal-hal lebih menarik, kecepatan dalam arah x
diatur ke nilai acak. Kita mengatur kecepatan untuk arah y ke -2, yang membuat
bola jatuh pada kecepatan yang wajar. Sekarang semuanya sudah diinisialisasi,
kita dapat mengimplementasikan utama permainan lingkaran. Metode pengolahan
imbang () adalah tempat yang sempurna:
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 mencetakAnda 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);
}
Update () fungsi sangat penting, karena itu update permainan collision-check,

bergerak bola, dan sebagainya:
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
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
}
}
Perhatikan bahwa collision-check juga mengubah kecepatan dari bola jika

diperlukan. Sekarang bola bergerak, itu akan adil untuk memindah pemukul, juga.
Seperti dikatakan sebelumnya, Anda mengendalikan dayung dengan memiringkan
kontroler game sekitar sumbu x. Berikut kode yang mendapat data pengontrol
melalui port serial:
Line 1 void serialEvent(Serial port) {

- final String arduinoData = port.readStringUntil(LINE_FEED);
- if (arduinoData!= null){
5 final int[] data = int(split(trim(arduinoData), ' '));
- if (data.length == 4){
- buttonPressed = (data[3] == 1);
- if (buttonPressed){
- paused =!paused;
10 if (done){
- done = false;
- initGame();
-}
-}
15
- if (!paused)
- xpos = int(map(data[0], X_AXIS_MIN, X_AXIS_MAX, 0, WIDTH));
-}
-}
20 }
Pengolahan panggilan serialEvent () fungsi setiap kali data baru tersedia

pada port serial. Controller mengirimkan data baris demi baris nya. masing-
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.
6.7 Aplikasi Proyek

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.

Kita memiliki beberapa item khusus seperti protoshield tersebut. Pastikan
bahwa itu duduk dengan benar di atas Arduino dan bahwa tidak satupun dari
konektor yang sengaja menyelinap masa lalu socket. Kadang-kadang header
keluar dari bentuk, sehingga mungkin terjadi. Periksa apakah Anda telah disolder
header pin dengan benar untuk breakout papan.
Gunakan kaca pembesar dan mempelajari setiap solder sendi tunggal
dengan hati-hati. Apakah Anda cukup menggunakan solder? Apakah Anda
menggunakan terlalu banyak dan menghubungkan dua sendi?
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

1. Sebuah perisai Ethernet untuk Arduino
2. Sebuah sensor suhu TMP36
3. A PIR sensor gerak inframerah
4. Sebuah papan breadboard
5. beberapa kabel
6.2 PC Transfer Sensor data ke Internet

Semuanya dimulai dengan 38.400 modem baud, Netscape Navigator 3,
dan salah satu disket AOL atau CD - ROM Anda punya di mail. Hari ini Anda
mungkin memiliki akses broadband melalui kabel, satelit, atau DSL, dan itu
mungkin tersedia di mana-mana di rumah Anda melalui WiFi. Jadi, kita akan
mulai dengan menggunakan koneksi yang ada untuk menghubungkan Anda
Arduino ke Internet.
Sebuah program berjalan pada PC Anda dan berkomunikasi dengan
Arduino menggunakan port serial. Setiap kali aplikasi membutuhkan Internet
akses, program pada PC berhubungan dengan itu. Menggunakan arsitektur ini,
Anda dapat tweet1 data sensor yang menarik. Kita akan membangun sebuah
sistem yang tweet pesan segera karena suhu di ruang kerja atau kantor melebihi
batas tertentu, yaitu, 32 derajat Celsius (90 derajat Fahrenheit). Cobalah
mengupload sketsa berikut untuk Arduino Anda :
Line 1 #define CELSIUS
- const unsigned int TEMP_SENSOR_PIN = 0;
5 const float SUPPLY_VOLTAGE = 5.0;
91
- void setup(){
-}
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.
6.3 Mendaftarkan Aplikasi di Twitter
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.
6.4 Tweeting Pesan dengan Processing

Pengolahan tidak memiliki dukungan Twitter, tetapi dalam program
Processing, kita memiliki akses langsung ke library Jawa, dan Anda dapat
menemukan beberapa yang baik Library Twitter for Java. Salah satunya adalah
twitter4j.5 Kita akan menggunakannya karena itu sangat matang dan memiliki
dukungan yang sangat baik OAuth.
Download dari situsnya, 6 dan mengekstrak ke folder sementara.
Tergantung pada versi Anda men-download, Anda akan menemukan sebuah file
bernama twitter4j-core-xyzjar atau twitter4j-core-xyz-SNAPSHOT.jar dalam
folder. Buka Processing IDE, membuat sketsa baru, dan kemudian drag dan drop
jar. untuk IDE (file jar. secara otomatis akan disalin ke lokal
folder bernama code). Itulah yang harus Anda lakukan untuk memberikan aplikasi
Anda akses ke library twitter4j.
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() {}
Seperti biasa, kita mengimpor library serial untuk berkomunikasi dengan

Arduino, dan kemudian kita mendefinisikan beberapa konstanta kita butuhkan
nanti. sebagian besar mereka mengandung kepercayaan yang kita butuhkan untuk
mengakses layanan Twitter. dengan MAX_WORKING_TEMP, Anda dapat
menentukan di mana suhu aplikasi mulai tweet. Ini bisa menjadi derajat Celcius
atau Fahrenheit nilai.
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 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();
}
}
Pelaksana Serial Komunikasi di Processing, pada halaman 126, Anda

belajar bagaimana menerapkan komunikasi serial di Processing. Setiap kali data
baru tiba di port serial, lingkungan runtime memanggil serialEvent () method. Di
sana kita mencoba untuk membaca satu baris teks, dan kemudian kita cek apakah
mengandung angka desimal yang diikuti oleh kosong dan C atau F karakter. Hal
ini membuat yakin kita sudah membaca aktual mengatur data suhu dan bukan
sampah digital.
Jika kita punya satu set data temperatur sintaksis benar, kita mengubahnya
menjadi benda mengambang dan cek untuk melihat apakah itu lebih besar dari
MAX_WORKING_TEMP (tidak ada yang harus dipaksa untuk bekerja pada suhu
yang tinggi!). Jika ya, kita panggilan tweetAlarm () dan tweet pesan untuk
mendorong beberapa pengikut untuk menyelamatkan kita. Kemudian kita
menunggu selama dua jam sampai kita cek berikutnya. Jika tidak,
kita menunggu lima menit dan memeriksa suhu lagi. TweetAlarm ( ) update
channel Twitter dan sederhana.
Dalam Java, kita membuat Twitter contoh baru menggunakan Twitter dan
mengatur kredensial konsumen kita dengan memanggil setOAuthConsumer ( ).
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.
Menggunakan PC full-blown sebagai relay Internet untuk Arduino Anda

nyaman, tetapi juga berlebihan untuk sebagian besar aplikasi. Pada bagian
berikutnya, Anda akan belajar bagaimana mengubah sebuah Arduino menjadi
sebuah perangkat jaringan yang nyata.
6.5 Berkomunikasi Menggunakan Perisai Ethernet

Pada bagian sebelumnya, Anda belajar bagaimana untuk membangun
aplikasi jaringan dengan Arduino dengan menggunakan koneksi jaringan PC
Anda. pendekatan ini bekerja dengan baik, tetapi juga memiliki beberapa
kelemahan. Masalah terbesar adalah bahwa Anda memerlukan PC yang lengkap,
sedangkan untuk banyak aplikasi Arduino yang kemampuan hardware akan
cukup. Pada bagian ini, Anda akan belajar bagaimana memecahkan masalah ini
dengan perisai Ethernet. Anda tidak dapat menghubungkan Arduino telanjang ke
jaringan. Tidak hanya perangkat keras kemampuan terlalu terbatas, juga tidak
memiliki port Ethernet. Itu berarti Anda tidak bisa pasang kabel Ethernet ke
dalamnya, dan untuk mengatasi hal ini pembatasan, Anda harus menggunakan
perisai Ethernet.
Perisai tersebut datang dengan chip Ethernet dan konektor Ethernet dan
mengubah Anda menjadi Arduino perangkat jaringan segera. Anda hanya perlu
pasang masuk Anda dapat memilih dari beberapa produk, mereka semua baik dan
melayani mereka Tujuan well.7 Untuk prototyping saya lebihresmiperisai, 8
karena dilengkapi dengan soket untuk semua pin. Juga pada saat tulisan ini tim
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:
Line 1 #include <SPI.h>

- #include <Ethernet.h>
- const unsigned int DAYTIME_PORT = 13;
5 const unsigned int BAUD_RATE = 9600;
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 :
Mac berisi alamat MAC kita akan digunakan untuk Ethernet
perisai. Sebuah alamat MAC adalah nomor 48 - bit yang unik
mengidentifikasi device.11 jaringan Biasanya, produsen menetapkan ini
identifier, tapi untuk perisai Ethernet, kita harus mengatur diri kita sendiri ;
kita menggunakan nomor acak.
Catatan penting : alamat MAC harus unik pada jaringan Anda.
Jika Anda menghubungkan lebih dari satu Arduino, pastikan mereka semua
memiliki alamat MAC yang berbeda!
Setiap kali Anda menghubungkan PC Anda ke Internet, mungkin akan
alamat IP baru melalui Dynamic Host Configuration Protocol
( DHCP ).12 Untuk sebagian besar aplikasi Arduino, implementasi DHCP
relatif mahal, sehingga Anda biasanya menetapkan alamat IP secara manual.
Dalam kebanyakan kasus, ini akan menjadi alamat lokal di 192.168.xy yang
Kisaran, kita menyimpan alamat ini dalam array my_ip.
Untuk mengaktifkan nama domain seperti time.nist.gov ke alamat IP,
Anda memerlukan akses ke Domain Name System ( DNS ). The Arduino
library standar tidak mendukung DNS, jadi kita harus mengetahui
IP alamat diri kita sendiri. Kita menetapkan ke time_server. Perintah telnet
sudah berbalik layanan DAYTIME nama domain ke dalam
Alamat IP bagi kita. Atau, Anda dapat menggunakan salah satu dari berikut
perintah untuk menentukan alamat IP nama domain :
maik> host time.nist.gov

time.nist.gov has address 192.43.244.18
maik> dig +short time.nist.gov
192.43.244.18
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
}
//...
Loop () fungsi sketsa kita dimulai dengan penundaan singkat, yang

memungkinkan semua komponen untuk menginisialisasi benar. Hal ini diperlukan
karena Ethernet perisai adalah perangkat otonom yang mampu bekerja secara
paralel ke Arduino. Sejalan 22, kita mencoba untuk menyambung ke layanan
DAYTIME. jika koneksi tidak dapat dibangun, kita mencetak pesan kesalahan.
Jika tidak, kita tunggu setengah detik untuk memberikan layanan beberapa
persiapan waktu, dan kemudian kita membaca dan mencetak karakter output
dengan karakter.
Perhatikan bahwa antarmuka klien mirip dengan antarmuka Serial kelas.
Dengan tersedia (), kita dapat memeriksa apakah beberapa byte masih tersedia,
dan membaca () mengembalikan byte berikutnya. Pada akhirnya, kita sebut stop ()
untuk memutuskan sambungan dari layanan dan kemudian kita mulai lagi.
Menyusun dan meng-upload program ke Arduino. Kemudian buka serial
memantau, dan Anda akan melihat sesuatu seperti ini:
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.
Selesai! Arduino kita langsung terhubung ke Internet, dan

bahkan melakukan sesuatu yang berguna: kita telah mengubahnya menjadi sebuah
jam yang sangat akurat. Semua dalam semua, jaringan dengan Arduino tidak
berbeda jauh dari jaringan dengan PC, jika Anda menggunakan perisai Ethernet.
Pada bagian berikutnya, Anda akan belajar bagaimana cara mengirim email
dengan Arduino.
103
6.6 Emailing dari Command Line

Sekarang kita tahu bagaimana untuk mengakses layanan jaringan, kita
akan terus membangun proyek lebih maju : sebuah alarm otomatis. jika seseorang
bergerak di ruang tamu kita, kita ingin mendapatkan email, jadi kita harus belajar
bagaimana untuk mengirim email dari Arduino. Meskipun email adalah layanan
penting, hanya sedikit orang yang tahu bagaimana benar-benar bekerja di
belakang layar. Untuk mengirim email dari Arduino, kita bisa memilih jalan yang
mudah dan menggunakan PC sebagai relay email.
Sebagai hacker sejati, kita akan mengikuti jalur yang lebih canggih dan
mengimplementasikan subset dari Simple Mail Transfer Protocol ( SMTP ).13
SMTP adalah protokol Internet yang khas. Ini hanya menggunakan teks, dan hal
ini terutama berbasis -line, yaitu, Anda bertukar informasi baris demi baris.
Tipikal email hanya terdiri dari beberapa atribut : pengirim, penerima, subjek, dan
badan pesan. Untuk mengirimkan email, Anda harus mengirim permintaan ke
server SMTP. Permintaan harus mematuhi spesifikasi SMTP.
Sebelum kita mengirim email menggunakan Arduino dan perisai Ethernet,
Anda harus belajar bagaimana untuk mengirim email dari baris perintah dengan
menggunakan perintah telnet. Untuk melakukannya, Anda harus mengetahui
alamat dari suatu SMTP server yang dapat Anda gunakan terlebih dahulu.
Petunjuk berikut mengasumsikan Anda menggunakan akun Google Mail
(http://gmail.com). Jika Anda menggunakan berbeda penyedia email, Anda harus
menyesuaikan nama domain sesuai. di kasus apapun, jangan penyalahgunaan
layanan mereka! Jika ragu, baca istilah penggunaannya!
Buka terminal, dan masukkan berikut ini:
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):
( maik> telnet gmail-smtp-in.l.google.com 25

) Trying 74.125.77.27...
Connected to gmail-smtp-in.l.google.com.
Escape character is '^]'.
220 mx.google.com ESMTP q43si10820020eeh.100
( HELO
) 250 mx.google.com at your service
( MAIL FROM: <arduino@example.com>
) 250 2.1.0 OK q43si10820020eeh.100
( RCPT TO: <info@example.com>
) 250 2.1.5 OK q43si10820020eeh.100
( DATA
) 354 Go ahead q43si10820020eeh.100
( from: arduino@example.com
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.
RCPT TO : Perintah menetapkan alamat email penerima. Jika Anda ingin

untuk mengirim email ke lebih dari satu penerima, Anda harus mengulangi
perintah untuk masing-masing.
Dengan perintah DATA, kita memberitahu server yang sekarang kita
mulai untuk mengirimkan
atribut email itu. Atribut Email terutama daftar kunci / nilai pasangan mana kunci
dan nilai yang dipisahkan oleh titik dua. Jadi dalam tiga pertama garis, kita
mengatur atributdari,untuk, dansubjek,dan mereka semua memiliki yang
berarti Anda harapkan ketika mengirim email.
Anda memisahkan tubuh email itu dari atribut menggunakan baris kosong
untuk menandai akhir dari badan email, mengirim baris yang berisi satu periode.
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.
6.7 Emailing Langsung dari Arduino

Untuk mengirim email dari Arduino, kita pada dasarnya akan
melaksanakan sesi telnet dari bagian baris sebelumnya demi baris. Alih-alih hanya
Hardwiring atribut email ke dalam kode jaringan, kita akan membuat
desain yang lebih canggih.
Kita mulai dengan kelas Email:
#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
Kelas ini merangkum empat atribut-email yang paling penting alamat

email dari pengirim dan penerima, subjek, dan badan pesan. Kita menyimpan
semua atribut sebagai obyek String. Tunggu sebentar... kelas String? Yes! Sejak
versi 19, Arduino IDE dilengkapi dengan string full-blown class.14 Ia tidak
memiliki banyak fitur sebagai C + + atau Java kelas string, tapi itu masih jauh
lebih baik daripada main-main dengan char pointer. Anda akan melihat bagaimana
menggunakannya dalam beberapa paragraf.
Sisanya kita kelas Email adalah cukup sederhana. Dalam konstruktor,
kita menginisialisasi semua variabel instan, dan kita memiliki metode untuk
mendapatkan setiap atribut tunggal. Kita sekarang membutuhkan kelas
SmtpService untuk mengirimkan Objek Email:
Line 1 #ifndef __SMTP_SERVICE__H_

- #define __SMTP_SERVICE__H_
- #includeemail.h"
5
- class SmtpService{
- byte* _smtp_server;
- unsigned int _port;
10 void read_response(Client& client){
- delay(4000);
- while (client.available()){
- const char c = client.read();
- Serial.print(c);
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 :
Line 1 #include <SPI.h>

- #include <Ethernet.h>
- #includesmtp_service.h"
5 const unsigned int SMTP_PORT = 25;
- byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
- byte my_ip[] = { 192, 168, 2, 120 };
10
- // Insert IP of your SMTP server below!
- byte smtp_server[] = { 0, 0, 0, 0 };
- SmtpService smtp_service(smtp_server, SMTP_PORT);
15
- void setup(){
- Ethernet.begin(mac, my_ip);
- delay(1000);
20 Email email(
-arduino@example.com",
-info@example.net",
111
-Yet another subject",

-Yet another body"
25 );
- smtp_service.send_email(email);
-}
- void loop() {}
Tidak ada kejutan di sini. Kita mendefinisikan konstanta, alamat MAC,

dan sebagainya, kemudian membuat sebuah contoh SmtpService. Dalam setup ()
fungsi, kita menginisialisasi port serial dan perisai Ethernet, kemudian menunggu
untuk kedua untuk membiarkan hal menetap sedikit. Pada baris 20, kita membuat
objek baru dan Email panggilan send_email nya () method. Sekarang kita tahu
cara mengirim email dengan Arduino, tetapi untuk membangun kita alarm
pencuri, kita masih harus belajar bagaimana untuk mendeteksi gerakan.
6.8 Mendeteksi Gerak Menggunakan Passive Infrared Sensor

Mendeteksi gerakan adalah teknik yang berguna, dan Anda mungkin
sudah tahu perangkat yang menyalakan lampu di kebun atau di depan pintu Anda
setiap kali seseorang cukup dekat. Sebagian besar dari mereka menggunakan
sensor inframerah pasif (PIR) 15 untuk mendeteksi gerakan.
Hampir setiap objek memancarkan cahaya inframerah, dan sensor PIR
langkah-langkah persis bagian ini cahaya. Mendeteksi gerakan adalah relatif
mudah jika Anda sudah dapat menerima radiasi inframerah dipancarkan oleh
benda-benda di lapangan sensor pandang. Jika sensor menerima cahaya
inframerah yang dipancarkan oleh dinding, misalnya, dan tiba-tiba manusia
sedang atau binatang bergerak di depan dinding, sinyal cahaya inframerah akan
berubah. Off - the- shelf sensor menyembunyikan rincian ini, sehingga Anda
dapat menggunakan single digital pin untuk memeriksa apakah seseorang
bergerak di lapangan sensor pandang.
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.
Kemudian masukkan kode berikut di Arduino IDE :
Line 1 const unsigned int PIR_INPUT_PIN = 2;

- class PassiveInfraredSensor{
5 int _input_pin;
- public:
- PassiveInfraredSensor(const int input_pin){
10 _input_pin = input_pin;
- pinMode(_input_pin, INPUT);
-}
- const bool motion_detected() const{
15 return digitalRead(_input_pin) == HIGH;
-}
- };
- PassiveInfraredSensor pir(PIR_INPUT_PIN);
20
- void setup(){
113
-}
25 void loop(){
- if (pir.motion_detected()){
- Serial.println("Motion detected");
- } else{
- Serial.println("No motion detected");
30 }
- delay(200);
-}
Dengan PIR_INPUT_PIN konstan, Anda dapat menentukan pin digital

Anda sudah Koneksi sensor PIR untuk. Sejalan 4, kita mulai definisi
kelas bernama PassiveInfraredSensor yang merangkum semua hal yang berkaitan
dengan Sensor PIR.
Kita mendefinisikan anggota variabel bernama _input_pin yang
menyimpan nomor pin digital kita sudah terhubung sensor kita. Kemudian kita
mendefinisikan konstruktor yang mengharapkan nomor pin sebagai argumen dan
memberikan ke variabel anggota kita.
Satu-satunya metode kita perlu mendefinisikan adalah motion_detected ( ).
Itu mengembalikan nilai true jika saat ini telah mendeteksi gerak dan fal se
sebaliknya. Jadi, itu harus periksa apakah hanya keadaan saat pin digital sensor
TINGGI atau LOW.
Kompilasi sketsa, meng-upload ke Arduino Anda, ketika Anda mulai
gelombang dengan tangan Anda di depan sensor. Sekarang kita telah membangun
dua komponen utama alarm pencuri kita, dan satu-satunya yang tersisa untuk
dilakukan adalah untuk membawa mereka berdua bersama-sama. Kita akan
melakukan itu dalam bagian berikutnya.
114
6.9 Menyatukan Semuanya

Dengan kita PassiveInfraredSensor dan SmtpService kelas, sangat mudah
untuk membangun sebuah alarm pencuri email. Hubungkan sensor PIR ke
Ethernet perisai dan upload kode berikut untuk Arduino Anda :
Line 1 #ifndef __BURGLAR_ALARM_H__

- #define __BURGLAR_ALARM_H__
- #includepir_sensor.h"
5 #includesmtp_service.h"
- class BurglarAlarm{
- PassiveInfraredSensor _pir_sensor;
- SmtpService _smtp_service;
10
- void send_alarm(){
- Email email(
-arduino@example.com",
-info@example.net",
15Intruder Alert!",
-Someone's moving in your living room!"
- );
- _smtp_service.send_email(email);
-}
20
- public:
- BurglarAlarm(
- const PassiveInfraredSensor& pir_sensor,
25 const SmtpService& smtp_service):
- _pir_sensor(pir_sensor),
- _smtp_service(smtp_service)
115
-{
-}
30
- void check(){
- Serial.println("Checking");
- if (_pir_sensor.motion_detected()){
- Serial.println("Intruder detected!");
35 send_alarm();
-}
-}
- };
40 #endif
Ini mendefinisikan kelas bernama BurglarAlarm yang mengumpulkan

semua kode kita telah menulis sejauh ini. Ini merangkum contoh SmtpService dan
PassiveInfraredSensor a objek. Metode yang paling kompleks adalah send_alarm
() yang mengirimkan email yang telah ditetapkan.
Sisa kelas BurglarAlarm adalah cukup sederhana. awal sejalan 23, kita
mendefinisikan konstruktor yang menginisialisasi semua anggota pribadi. Cek ()
metode cek apakah sensor PIR telah mendeteksi gerakan. Jika tidak, kita
mengirim email.
Mari kita gunakan kelas BurglarAlarm:
#include <SPI.h>
#include <Ethernet.h>
#includeburglar_alarm.h"
const unsigned int PIR_INPUT_PIN = 2;
const unsigned int SMTP_PORT = 25;
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);
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
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
: Muhammad Bangun Agung

: 202136575862733
: Onno W. Purbo
: Surya Unversity
cxxii

ARDUINO BEGINNER

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ARDUINO BEGINNER

Uploaded by

Copyright:

Available Formats

17 Maret 2014

ARDUINO FOR BEGINNERS

3.8 Kesalahan-kesalahan yang Mungkin Terjadi .................................................. 50

Gambar 1.1. Jenis-jenis Arduino.

Mereka mungkin berbeda dalam penampilan mereka, tetapi mereka

1.2 Yang Anda butuhkan

Pins Digital I/O

Pin Analog Input

Gambar 1.2. Bagian-bagian Arduino (Diecimila).

Untuk menghubungkan Arduino ke komputer Anda, Anda hanya

Sebagai perangkat elektronik, Arduino membutuhan daya (power). Salah

hanya memberikan 5 volt, dan kadang-kadang Anda membutuhkan lebih banyak

1.3 Instalasi Arduino IDE

Instalasi Arduino IDE pada Windows

Instalasi Arduino IDE pada Mac OS X

Instalasi Arduino IDE di Linux

1.4 Arduino IDE

Gambar 1.3. Tampilan Arduino IDE.

Gambar 1.4. Toolbar Arduino IDE.

Meskipun menggunakan IDE sangat mudah, Anda mungkin mengalami

const unsigned int LED_PIN = 13;

1.5 Tipe-tipe Data dalam Arduino

int values[2]; // Array dengan dua elemen

Arduino panggilan setup () sekali ketika boot, dan kita menggunakannya

1.6 Kompilasi dan Program Uploading

Selama proses upload, TX dan RX LED akan berkedip selama beberapa

lubang bagian, Anda dapat melihat beberapa di mengapa mereka biasanya

1.8 Kesalahan-kesalahan yang Mungkin Terjadi

Bagian Dalam Arduino

2.1 Yang Anda Butuhkan

2.2 Mengelola Proyek dan Sketsa

2.3 Mengubah Preferensi

2.4 Menggunakan Port Serial

Seperti pada contoh sebelumnya, kita mendefinisikan sebuah konstanta

angka desimal 4711 dapat direpresentasikan dalam oktal dan heksadesimal

2.5 Kesalahan-kesalahan yang Mungkin Terjadi

3.1 Yang Anda Butuhkan

3.3 Menggunakan LED pada Breadboard

breadboard. Pastikan bahwa Anda masih dapat mengidentifikasi negatif dan

3.4 Dice Binary

const unsigned int LED_BIT0 = 12;

Kompilasi kode, meng-upload ke Arduino, dan bermain sedikit dengan

3.5 Tombol-tombol yang Ada

const unsigned int BUTTON_PIN = 7;

Kita menghubungkan tombol ke pin 7 dan LED untuk pin 13 dan

const unsigned int BUTTON_PIN = 7;

const unsigned int BUTTON_PIN = 7;

Setelah inisialisasi tombol dan pin LED, kita mendeklarasikan dua

const unsigned int BUTTON_PIN = 7;

3.6 Menambahkan Tombol

const unsigned int LED_BIT0 = 12;

3.7 Membuat Permainan Dadu

salahnya untuk membaca petunjuk instalasi dan dokumentasi di halaman web.

- void output_result(const long result){

3.8 Kesalahan-kesalahan yang Mungkin Terjadi

Membuat Morse Code

4.1 Yang Anda Butuhkan

4.2 Mempelajari Dasar-dasar dari Kode Morse

4.3 Membuat Morse Code Generator

Telegraph telegraph(13, 200);

4.4 Interface Generator

Telegraph::Telegraph(const int output_pin, const int dit_length) {