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.
i
Daftar Isi Kata Pengantar ......................................................................................................... i Daftar Isi ................................................................................................................. ii Pendahuluan ............................................................................................................ 1 Bab 1 Mengenal Arduino ........................................................................................ 2 1.1 Apakah Arduino itu? ......................................................................................... 3 1.2 Yang Anda butuhkan ........................................................................................ 5 1.3 Instalasi Arduino IDE ....................................................................................... 8 Instalasi Arduino IDE pada Windows ................................................................. 9 Instalasi Arduino IDE pada Mac OS X ............................................................... 9 Instalasi Arduino IDE di Linux ......................................................................... 10 1.4 Arduino IDE .................................................................................................... 10 1.5 Tipe-tipe Data dalam Arduino ........................................................................ 13 1.6 Kompilasi dan Program Uploading................................................................. 15 1.7 LED ................................................................................................................. 17 1.8 Kesalahan-kesalahan yang Mungkin Terjadi .................................................. 18 1.9 Latihan ............................................................................................................ 19 2.1 Yang Anda Butuhkan ...................................................................................... 20 2.2 Mengelola Proyek dan Sketsa ......................................................................... 21 2.3 Mengubah Preferensi ...................................................................................... 22 2.4 Menggunakan Port Serial ................................................................................ 23 2.5 Kesalahan-kesalahan yang Mungkin Terjadi .................................................. 29 2.6 Latihan ............................................................................................................ 29 Bab 2 Proyek-proyek Arduino .............................................................................. 31 3.1 Yang Anda Butuhkan ...................................................................................... 32 3.2 Breadboards .................................................................................................... 33 3.3 Menggunakan LED pada Breadboard ............................................................. 34 3.4 Dice Binary ..................................................................................................... 35 3.5 Tombol-tombol yang Ada ............................................................................... 38 3.6 Menambahkan Tombol ................................................................................... 43 3.7 Membuat Permainan Dadu.............................................................................. 45 ii
3.8 Kesalahan-kesalahan yang Mungkin Terjadi .................................................. 50 3.9 Latihan ............................................................................................................ 50 4.1 Yang Anda Butuhkan ...................................................................................... 52 4.2 Mempelajari Dasar-dasar dari Kode Morse .................................................... 52 4.3 Membuat Morse Code Generator .................................................................... 53 4.4 Interface Generator.......................................................................................... 55 4.5 Output Simbol Kode Morse ............................................................................ 57 4.6 Memasang dan Menggunakan Class Telegraph .............................................. 59 4.7 Sentuhan Akhir ............................................................................................... 63 4.8 Kesalahan-kesalahan yang Mungkin Terjadi .................................................. 65 4.9 Latihan ............................................................................................................ 65 5.1 Yang Anda Butuhkan ...................................................................................... 69 5.2 Accelerometer ................................................................................................. 69 5.3 Menghidupkan Accelerometer ........................................................................ 70 5.5 Kontroler dan Game ........................................................................................ 76 5.6 Membuat Game Sendiri .................................................................................. 79 6.7 Aplikasi Proyek ............................................................................................... 88 6.8 Kesalahan-kesalahan yang Mungkin Terjadi .................................................. 89 6.9 Latihan ............................................................................................................ 89 6.1 Yang Anda Butuhkan ...................................................................................... 91 6.2 PC Transfer Sensor data ke Internet................................................................ 91 6.3 Mendaftarkan Aplikasi di Twitter ................................................................... 93 6.4 Tweeting Pesan dengan Processing ................................................................ 94 6.5 Berkomunikasi Menggunakan Perisai Ethernet .............................................. 98 6.6 Emailing dari Command Line ....................................................................... 104 6.7 Emailing Langsung dari Arduino .................................................................. 107 6.8 Mendeteksi Gerak Menggunakan Passive Infrared Sensor ........................... 112 6.9 Menyatukan Semuanya ................................................................................. 115 6.10 Kesalahan-kesalahan yang Mungkin Terjadi .............................................. 118 6.11 Latihan ........................................................................................................ 119 Daftar Pustaka ...................................................................................................... cxx Lampiran ........................................................................................................... cxxii
iii
Pendahuluan Selamat datang di Arduino dan dunia menarik dari komputasi fisik. Arduino adalah sebuah proyek open source yang terdiri dari perangkat keras dan perangkat lunak. Pada awalnya, Arduino diciptakan untuk memberikan desainer dan seniman platform prototyping untuk kursus desain interaksi. Sekarang para penggemar Arduino dan para ahli di seluruh dunia menggunakannya untuk membuat proyek komputasi fisik, dan sekarang Anda juga bisa. 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.
1
Bab 1 Mengenal Arduino
2
Selamat datang di Arduino 1.1 Apakah Arduino itu? Arduino awalnya dibangun untuk desainer dan seniman - orang dengan keahlian teknis sedikit. Bahkan tanpa pengalaman pemrograman, Arduino memungkinkan mereka untuk membuat prototipe desain yang canggih dan beberapa karya seni interaktif yang menakjubkan. Jadi, seharusnya tidak mengejutkan bahwa langkah pertama dengan Arduino sangat mudah, bahkan lebih mudah lagi untuk orang-orang dengan latar belakang teknis yang kuat. Akan tetapi mendapatkan dasar-dasar yang. Anda akan mendapatkan hasil maksimal bekerja dengan Arduino jika Anda terbiasa dengan papan Arduino sendiri, dengan perkembangan dari Arduino sendiri, dan dengan teknik seperti komunikasi serial. Satu hal yang perlu dipahami sebelum memulai komputasi fisik. Jika Anda telah bekerja dengan komputer sebelumnya, Anda mungkin akan bertanya-tanya, apakah maksud dari komputasi fisik? Karena komputer sendiri adalah benda fisik dan menerima input dari keyboard dan mouse. Mereka memberikan output berupa suara dan video untuk speaker fisik dan menampilkan gambar. Jadi, bukankah semua komputasi pada komputer adalah komputasi fisik pada akhirnya? 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.
3
Di dalam bab ini Anda akan belajar bagaimana Anda akan memulai dengan komputasi fisik dengan belajar bagaimana mengontrol Arduino, alat-alat apa saja yang Anda butuhkan, dan cara menginstal dan mengkonfigurasi mereka. Kemudian kita akan cepat sampai ke bagian yang menyenangkan; Anda akan mengembangkan program pertama Anda untuk Arduino. 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.
4
Mereka mungkin berbeda dalam penampilan mereka, tetapi mereka memiliki banyak kesamaan, dan Anda dapat memprogram mereka semua dengan alat dan library yang sama. Selain papan resmi, Anda juga dapat menemukan berbagai tiruan Arduino yang tak terhitung jumlahnya di internet. Semua orang diperbolehkan untuk menggunakan dan mengubah desain papan asli, dan banyak orang membuat versi mereka sendiri dari papan Arduino, misalnya Freeduino, Seeduino, Boarduino, dan Paperduino yang papan sirkuitnya berupa kertas. Arduino adalah merek dagang terdaftar dan hanya papan resmi yang diberi nama"Arduino". Tiruan-tiruannya biasanya diakhiri dengan”duino.”Anda dapat menggunakan setiap tiruan yang sepenuhnya kompatibel dengan Arduino asli untuk membangun semua proyek di dalam buku ini.
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.
5
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
6
hanya memberikan 5 volt, dan kadang-kadang Anda membutuhkan lebih banyak daya. Dalam situasi ini, solusi terbaik biasanya adalah adaptor AC yang memberikan tegangan 9V (kisaran yang direkomendasikan adalah 7V untuk 12V). Anda membutuhkan adaptor dengan ujung laras 2,1 mm dan pusat positif (tanyakan kepada orang yang menjualnya). Tancapkan ke power plug Arduino, dan Arduino bisa segera dinyalakan, bahkan ketika tidak terhubung ke komputer. Dengan cara itu, jika Anda menghubungkan Arduino ke port USB, Arduino akan menggunakan daya eksternal jika tersedia. Harap diperhatikan bahwa beberapa versi papan Arduino seperti 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.
7
Mereka mengambil data sensor dan mengubahnya menjadi angka antara 0 dan 1023. Di bagian atas papan ada 14 pin digital IO bernama D0 - D13. tergantung kepada kebutuhan Anda, Anda dapat menggunakan pin-pin untuk input atau output digtal, sehingga Anda dapat menghidupkan dan mematikan LED. Pin-pin tersebut (D3, D5, D6, D9, D10, dan D11) juga dapat bertindak sebagai input/output analog. Dalam mode ini, mereka mengkonversi dari 0 sampai 255 angka digital menjadi tegangan analog. Semua pin ini dihubungkan ke mikrokontroler. Mikrokontroler menggabungkan CPU dengan beberapa fungsi periferal seperti saluran I/O. Ada banyak jenis mikrokontroler yang tersedia, tetapi biasanya Arduino dilengkapi dengan ATmega328 atau ATmega168. Keduanya adalah mikrokontroler 8-bit yang diproduksi oleh sebuah perusahaan bernama Atmel. Meskipun komputer modern memuat program dari hard drive, mikrokontroler biasanya harus diprogram terlebih dahulu. Itu berarti Anda harus memuat perangkat lunak Anda ke mikrokontroler melalui kabel. Anda hanya perlu mengunggahnya ke dalam mikrokontroler sekali saja. Program tersebut akan tetap berada di dalam mikrokontroler sampai mendapat program baru. Setiap kali Anda memberikan suplai listrik ke Arduino, program byang ada dalam mikro kontroler akan disimpan dalam mikrokontroler dan dijalankan secara otomatis. Jika Anda menekan tombol reset pada Arduino, semuanya akan reinitialized. Program yang telah disimpan tidak akan hilang, namun berjalan dari awal.
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.
8
Instalasi Arduino IDE pada Windows Arduino IDE berjalan pada semua versi terbaru dari Microsoft Windows, seperti Windows XP, Windows Vista, dan Windows 7, dan Windows 8. Instalasi IDE untuk Windows sangat mudah, karena IDE Arduino untuk Windows diunduh sebagai arsip ZIP mandiri, sehingga Anda tidak memerlukan sebuah installer. Unduh arsip, dan ekstrak ke lokasi pilihan Anda. Sebelum Anda pertama kali menjalankan IDE, Anda harus menginstal driver untuk Arduino Port USB. Proses ini tergantung pada papan Arduino Anda dan versi Windows yang digunakan, tetapi Anda selalu harus memasang Arduino ke port USB pertama untuk memulai proses instalasi driver. Pada Windows Vista, instalasi driver biasanya terjadi secara otomatis. Windows XP dan Windows 7 tidak dapat memperbarui/mengupdate dari situs Arduino secara otomatis. Cepat atau lambat wizard hardware akan meminta Anda untuk menyambungkan ke path ke driver yang tepat setelah Anda telah diberitahu untuk melewati instalasi driver otomatis dari Internet. Tergantung dari papan Arduino Anda, Anda harus menunjuk ke lokasi/direktori yang telah di instalasi Arduino. Untuk Arduino Uno dan Arduino mega 2560, pilih Arduino UNO.inf di direktori driver. Untuk papan yang lebih tua seperti Duemilanove, Diecimila, atau Nano, pilih driver / FTDI direktori Driver USB. Setelah driver terinstal, Anda dapat memulai Arduino executable dari direktori utama dengan mengklik dua kali. Ikuti petunjuk yang diberikan untuk menginstal IDE. Perlu diketahui bahwa driver USB tidak berubah sesering Arduino IDE. Setiap kali Anda menginstal versi baru dari IDE, periksa apakah Anda perlu menginstal driver baru juga.
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
9
yang Arduino lebih tua seperti Duemilanove, Diecimila, atau Nano, Anda harus menginstal driver untuk port serial Arduino itu. Double klik file FTDIUSBSerialDriver_10_4_10_5_10_6.pkg untuk platform Anda, dan ikuti petunjuk instalasi. Ketika menginstal versi baru dari Arduino IDE, Anda biasanya tidak perlu menginstal driver FTDI lagi (hanya jika ada versi yang lebih baru).
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
') '
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 melampirkan”nyata”LED ke Arduino.
1.7 LED LED yang datang dengan Arduino bagus untuk tujuan pengujian, tapi Anda tidak harus menggunakan mereka dalam proyek-proyek elektronik Anda sendiri. Mereka semua memiliki arti khusus, dan itu adalah gaya buruk untuk menggunakannya dalam konteks yang berbeda. Juga, mereka sangat kecil dan tidak sangat terang, jadi itu adalah ide yang baik untuk mendapatkan beberapa LED dan tambahan belajar bagaimana untuk menghubungkan mereka ke Arduino. Ini sangat mudah. Kita tidak akan menggunakan jenis yang sama dari LED yang dipasang di Arduino papan. Mereka adalah perangkat permukaan - mount (SMD) yang sulit untuk menangani. Anda jarang akan bekerja dengan bagian-bagian SMD, karena bagi sebagian besar dari mereka Anda membutuhkan peralatan khusus dan banyak pengalaman. Mereka menghemat biaya segera setelah Anda mulai produksi massal dari perangkat elektronik, tetapi murni penggemar tidak akan membutuhkan mereka sering. LED yang kita butuhkan adalah melalui
17
lubang bagian, Anda dapat melihat beberapa di mengapa mereka biasanya memiliki satu atau lebih kabel panjang. Pertama Anda menempatkan kabel melalui lubang di papan sirkuit cetak. Maka Anda biasanya membungkuk, solder, dan memotong mereka untuk melampirkan bagian ke papan tulis. Bila tersedia, Anda juga dapat plug mereka ke soket seperti yang kita miliki pada Arduino atau pada breadboards. Pasang konektor pendek dari LED ke tanah pin (GND) dan satu lagi ke pin 13. Anda dapat melakukannya saat berkedip sketsa masih berjalan. Kedua LED status dan LED eksternal akan mulai berkedip. Benar-benar memastikan bahwa Anda menggunakan pin 13! Jika Anda menghubungkan LED untuk setiap pin lain, mungkin akan hancur. Alasannya adalah pin yang 13 memiliki resistor internal yang pin lainnya tidak memiliki. Anda baru saja menambahkan bagian elektronik eksternal pertama Anda untuk Anda Arduino, dan Anda telah membuat proyek komputasi fisik pertama Anda. Anda telah menulis beberapa kode, dan itu membuat dunia sedikit lebih cerah. anda versi digital sendiri dari”fiat lux”13 Anda akan membutuhkan teori dan keterampilan yang telah Anda pelajari dalam bab ini untuk hampir setiap proyek Arduino. Dalam bab berikutnya, Anda akan melihat bagaimana mendapatkan kontrol lebih besar atas LED, dan Anda akan belajar bagaimana untuk mendapatkan keuntungan dari lebih fitur canggih dari Arduino IDE.
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 seperti”Serial port sudah digunakan”ketika meng-upload sketsa, periksa apakah Anda telah memilih hak port serial dari menu Tools> Serial Port. Jika Anda mendapatkan pesan seperti”upload error”atau”program did not respond,”periksa apakah Anda telah memilih yang tepat Arduino papan dari Menu Tools> Board. Program Arduino Anda, seperti semua program, akan mengandung bug. Typos dan kesalahan sintaks akan terdeteksi oleh kompilator. Pada Gambar 1.13, sebagai berikut halaman, Anda dapat melihat pesan error yang khas. Alih-alih pinMode (), kita disebut pinMod (), dan karena compiler tidak menemukan fungsi memiliki nama itu, berhenti dengan pesan error. Arduino IDE menyoroti garis, menunjukkan kesalahan dengan latar belakang kuning, dan mencetak pesan kesalahan membantu. Bug lain mungkin lebih halus dan kadang-kadang Anda harus hati-hati mempelajari kode Anda dan menggunakan beberapa teknik debugging. Mungkin saja, walaupun jarang, Anda menggunakan LED yang rusak. Jika tidak ada trik yang disebutkan membantu, cobalah LED lain.
1.9 Latihan • Cobalah pola blink yang berbeda menggunakan lebih jeda dan bervariasi jeda panjang (mereka tidak perlu harus semua sama). Juga, percobaan dengan jeda yang sangat singkat yang membuat LED berkedip pada tinggi frekuensi. Dapatkah Anda menjelaskan efek Anda mengamati ? • Biarkan output nama Anda LED dalam kode Morse.
19
Bagian Dalam Arduino Untuk aplikasi sederhana, semua yang Anda telah belajar tentang Arduino IDE di bab sebelumnya sudah cukup. Tapi segera proyek Anda akan mendapatkan lebih banyak ambisius, dan kemudian akan berguna untuk membagi mereka menjadi terpisah file yang dapat Anda mengelola secara keseluruhan. Jadi dalam bab ini, Anda akan belajar bagaimana untuk tetap dalam kontrol atas 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 dari”serial”- dan kapan terakhir kali Anda melihat port paralel ? (Mungkin ini adalah saat yang tepat untuk membersihkan garasi dan membuang bahwa PC lama yang Anda ingin berubah menjadi media center suatu hari nanti....) Untuk meng-upload software, Arduino memiliki port serial, dan kita dapat menggunakannya untuk menghubungkan Arduino ke perangkat lain, juga (dalam Bagian 1.6, Kompilasi Program Uploading, pada halaman 38, Anda belajar bagaimana untuk mencari port serial Arduino Anda terhubung ke). Pada bagian ini, kita akan menggunakan untuk mengontrol status LED Arduino yang menggunakan keyboard komputer kita. itu LED harus diaktifkan ketika Anda
23
menekan 1, dan itu harus berubah off ketika Anda menekan 2. Berikut semua kode yang kita butuhkan : Line 1 const unsigned int LED_PIN = 13; - const unsigned int BAUD_RATE = 9600; - void setup(){ 5 pinMode(LED_PIN, OUTPUT); - Serial.begin(BAUD_RATE); -} - void loop(){ 10 if (Serial.available() > 0){ - int command = Serial.read(); - if (command == '1'){ - digitalWrite(LED_PIN, HIGH); - Serial.println("LED on"); 15 } else if (command == '2'){ - digitalWrite(LED_PIN, LOW); - Serial.println("LED off"); - } else{ - Serial.print("Unknown command:”); 20 Serial.println(command); -} -} -}
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 pesan”LED pada”melalui port serial. Kita menggunakan Serial.println (), yang menambahkan karakter carriage return (kode ASCII 13) diikuti oleh baris baru (kode ASCII 10) ke teks. Jika kita menerima karakter 2, kita matikan LED. Jika kita menerima perintah yang tidak didukung, kita mengirim kembali pesan yang sesuai dan perintah kita tidak mengerti. Serial.print () bekerja sama persis seperti Serial.println (), tetapi tidak menambahkan carriage return dan karakter newline pesan tersebut. Mari kita lihat bagaimana program itu bekerja dalam prakteknya. 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 pesan”LED pada”muncul 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 pesan”Unknown command :. 65”Jumlah 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
2.5 Kesalahan-kesalahan yang Mungkin Terjadi Jika Anda masih mengalami masalah, mungkin karena beberapa masalah dengan komunikasi serial. Sebagai contoh, Anda mungkin telah mengatur baud yang salah tingkat. Pastikan bahwa baud rate yang telah ditetapkan dalam ajakan Anda untuk Serial.begin () sesuai dengan baud rate pada monitor serial.
2.6 Latihan • 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.
3.1 Yang Anda Butuhkan 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 breadboard”mengemulasi”papan 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; - const unsigned int LED_BIT2 = 10; 5 void setup(){ - pinMode(LED_BIT0, OUTPUT); - pinMode(LED_BIT1, OUTPUT); - pinMode(LED_BIT2, 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); - digitalWrite(LED_BIT2, result & B100);
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; const unsigned int LED_PIN = 13; 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 BUTTON_PIN = 7; - const unsigned int LED_PIN = 13; - void setup(){ 5 pinMode(LED_PIN, OUTPUT); - 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 :
const unsigned int BUTTON_PIN = 7; const unsigned int LED_PIN = 13; void setup() { pinMode(LED_PIN, OUTPUT); pinMode(BUTTON_PIN, INPUT); } 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 BUTTON_PIN = 7; - const unsigned int LED_PIN = 13; - void setup(){ 5 pinMode(LED_PIN, OUTPUT); - pinMode(BUTTON_PIN, INPUT); -} - int old_button_state = LOW; 10 int led_state = LOW; - void loop(){ - const int CURRENT_BUTTON_STATE = digitalRead(BUTTON_PIN); - if (CURRENT_BUTTON_STATE!= old_button_state && 15 CURRENT_BUTTON_STATE == HIGH) -{ - led_state = (led_state == LOW) ? HIGH : LOW; - digitalWrite(LED_PIN, led_state); - delay(50); 20 }
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:
const unsigned int LED_BIT0 = 12; const unsigned int LED_BIT1 = 11; const unsigned int LED_BIT2 = 10; const unsigned int BUTTON_PIN = 7; void setup() { pinMode(LED_BIT0, OUTPUT); pinMode(LED_BIT1, OUTPUT); pinMode(LED_BIT2, OUTPUT); pinMode(BUTTON_PIN, INPUT);
43
randomSeed(analogRead(A0)); } int current_value = 0; int old_value = 0; void loop() { current_value = digitalRead(BUTTON_PIN); if (current_value!= old_value && current_value == HIGH){ output_result(random(1, 7)); delay(50); } old_value = current_value; } void output_result(const long result) { digitalWrite(LED_BIT0, result & B001); digitalWrite(LED_BIT1, result & B010); digitalWrite(LED_BIT2, result & B100); } - void loop(){ - const int CURRENT_BUTTON_STATE = digitalRead(BUTTON_PIN); - if (CURRENT_BUTTON_STATE!= old_button_state && 15 CURRENT_BUTTON_STATE == HIGH) -{ - led_state = (led_state == LOW) ? HIGH : LOW; - digitalWrite(LED_PIN, led_state); - delay(50); 20 } - old_button_state = CURRENT_BUTTON_STATE; -}
Itu gabungan sempurna dari kode asli dan kode yang diperlukan untuk kontrol tombol debounced. Seperti biasa, kita menginisialisasi semua pin yang kita gunakan : tiga untuk LED dan satu input pin untuk tombol pin output. Kita
44
juga menginisialisasi benih acak, dan dalam lingkaran () fungsi kita tunggu baru menekan tombol. Setiap kali tombol ditekan akan, kita melempar dadu dan output hasil menggunakan LED. Kita telah digantikan tombol reset dengan kita sendiri! Sekarang kita tahu betapa mudahnya untuk menambahkan tombol tekan, kita akan menambah satu di bagian berikutnya untuk mengubah dadu sederhana kita menjadi sebuah permainan.
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 - const unsigned int LED_BIT0 = 12; - const unsigned int LED_BIT1 = 11; 5 const unsigned int LED_BIT2 = 10; - const unsigned int START_BUTTON_PIN = 5; - const unsigned int GUESS_BUTTON_PIN = 7; - const unsigned int BAUD_RATE = 9600; 10 void setup(){ - pinMode(LED_BIT0, OUTPUT); - pinMode(LED_BIT1, OUTPUT); - pinMode(LED_BIT2, OUTPUT); - pinMode(START_BUTTON_PIN, INPUT); 15 pinMode(GUESS_BUTTON_PIN, INPUT); - randomSeed(analogRead(A0)); - Serial.begin(BAUD_RATE); -} 20 const unsigned int DEBOUNCE_DELAY = 20; - Bounce start_button(START_BUTTON_PIN, DEBOUNCE_DELAY); - Bounce guess_button(GUESS_BUTTON_PIN, DEBOUNCE_DELAY); - int guess = 0; 25 void loop(){ - handle_guess_button(); - handle_start_button(); -} -
46
30 void handle_guess_button(){ - if (guess_button.update()){ - if (guess_button.read() == HIGH){ - guess = (guess % 6) + 1; - output_result(guess); 35 Serial.print("Guess:”); - Serial.println(guess); -} -} -} 40 - void handle_start_button(){ - if (start_button.update()){ - if (start_button.read() == HIGH){ - const int result = random(1, 7); 45 output_result(result); Serial.print("Result:”); - Serial.println(result); - if (guess > 0){ - if (result == guess){ 50 Serial.println("You win!"); - hooray(); - } else{ - Serial.println("You lose!"); -} 55 } - delay(2000); - guess = 0; -} -} 60 } -
47
- void output_result(const long result){ - digitalWrite(LED_BIT0, result & B001); - digitalWrite(LED_BIT1, result & B010); 65 digitalWrite(LED_BIT2, result & B100); -} - void hooray(){ - for (int i = 0; i < 3; i++){ 70 output_result(7); - delay(500); - output_result(0); - delay(500); -} 75 }
Diakui bahwa banyak kode, tapi kita tahu sebagian besar sudah, dan bagian-bagian baru cukup mudah. Pada baris pertama, kita termasuk library Bounce kita akan menggunakan nanti untuk menghilangkan bounce dua tombol kita. Kemudian kita mendefinisikan konstanta untuk semua pin yang kita gunakan, dan di setup () metode, kita menginisialisasi semua kita pin dan mengatur benih acak. Kita juga menginisialisasi port serial, karena kita akan keluaran beberapa pesan debug. The Bounce library menyatakan kelas bernama Bounce, dan Anda harus membuat objek Bounce untuk setiap tombol yang ingin Anda menghilangkan bounce. Itulah yang terjadi di jalur 21 dan 22. Konstruktor dari kelas Bounce mengharapkan jumlah pin tombol yang terhubung ke dan menghilangkan bounce yang keterlambatan dalam milidetik. Akhirnya, kita menyatakan dan menginisialisasi variabel bernama menebak yang menyimpan dugaan kita saat ini. Our lingkaran () fungsi telah dikurangi menjadi dua fungsi panggilan. salah satunya adalah bertanggung jawab untuk menangani tombol menebak dorongan, dan yang lain menangani dorongan dari tombol start. Dalam handle_guess_button (), kita menggunakan Bounce Class untuk pertama kalinya.
48
Untuk menentukan keadaan saat ini kita guess_button objek, kita harus memanggil update () method. Setelah itu, kita membaca status saat ini menggunakan read () method. Jika tombol ditekan, negara yang diatur ke TINGGI, dan kita kenaikan variabel menebak. Untuk memastikan bahwa tebakan selalu dalam kisaran antara 1 dan 6, kita menggunakan operator modulus (%) sejalan 33. ini Operator membagi dua nilai dan mengembalikan sisanya. Untuk 6, ia mengembalikan nilai antara 0 dan 5, karena ketika Anda membagi angka dengan 6, yang sisanya selalu antara 0 dan 5. Tambahkan 1 pada hasil, dan Anda mendapatkan nilai antara 1 dan 6. Akhirnya, kita menebak saat ini menggunakan tiga LED, dan kita juga mencetak ke port serial. Penanganan tombol start di handle_start_button () bekerja sama persis sama seperti penanganan tombol menebak. Ketika tombol start ditekan, kita menghitung hasil baru dan output pada port serial. Kemudian kita cek apakah pengguna telah memasuki menebak (menebak lebih besar dari nol dalam kasus ini) dan apakah pengguna telah menebak kanan hasil. Dalam kedua kasus, kita mencetak pesan ke port serial, dan jika pengguna menebak dengan benar, kita juga memanggil hore () method. hore () memungkinkan semua tiga LED berkedip beberapa kali. Pada akhir metode ini, kita menunggu selama dua detik sampai pertandingan dimulai lagi, dan kita mengatur kembali menebak saat ini ke nol. Setelah Anda meng-upload software ke Arduino, mulai seri IDE memantau. Ini akan mencetak nilai sekarang dari variabel menebak setiap kali Anda menekan tombol menebak. Tekan tombol start, dan hasil baru muncul. Dalam bab ini, Anda menyelesaikan proyek Arduino benar-benar kompleks pertama Anda. Anda membutuhkan breadboard, LED, tombol, resistor, dan kabel, dan Anda menulis sepotong trivial perangkat lunak untuk membuat semua perangkat keras datang ke hidup. Pada bab selanjutnya, kita akan menulis sebuah program yang lebih canggih untuk menghasilkan kode Morse. Anda juga akan belajar cara membuat Arduino sendiri library yang Anda dapat dengan mudah berbagi dengan seluruh dunia.
49
3.8 Kesalahan-kesalahan yang Mungkin Terjadi Banyak hal mungkin akan salah bila Anda bekerja dengan breadboards untuk pertama kalinya. Masalah terbesar biasanya adalah bahwa Anda tidak terhubung bagian dengan benar. Butuh beberapa waktu untuk menemukan teknik yang tepat untuk memasukkan LED, kabel, resistor, dan tombol ke papan tempat breadboard. Anda memiliki untuk menekan tegas tapi tidak terlalu keras jika tidak, anda akan menekuk konektor, dan mereka tidak akan cocok. Ini biasanya lebih mudah untuk plug bagian dalam setelah Anda dipersingkat konektor. Ketika memotong konektor, memakai kacamata keselamatan untuk melindungi mata Anda! Sementara mengutak-atik main dengan bagian-bagian, jangan lupa bahwa beberapa dari mereka - LED, misalnya - membutuhkan arah tertentu. Pushbuttons adalah kandidat potensi masalah, juga. Perhatikan pada pushbuttons pada halaman 74 dan pastikan bahwa Anda telah terpasang mereka ke arah yang benar. Bahkan hal-hal sederhana seperti kabel biasa dapat menyebabkan masalah, terutama jika mereka tidak panjang yang tepat. Jika kawat terlalu pendek dan mungkin berpotensi menyelinap keluar dari soketnya, menggantinya segera. Kabel terlalu murah untuk membuang waktu berharga Anda dengan tidak perlu dan mengganggu sesi debugging.
3.9 Latihan • Dadu Binary semua sangat baik ketika Anda sedang bermain Monopoli dengan teman geeky Anda, tetapi kebanyakan orang lebih memilih dadu lebih akrab. coba mengubah dadu biner ke desimal dadu dengan tujuh LED. mengatur LED seperti mata dadu biasa. • 1k resistor kita telah digunakan untuk melindungi LED kita dalam bab ini agak besar. • LED dapat digunakan untuk lebih dari menampilkan hasil dadu biner. Asalkan Anda memiliki cukup LED, Anda dapat dengan mudah membangun hal-hal lain,
50
biner Anda sudah cukup tahu tentang elektronika dan pemrograman Arduino untuk membangun jam biner Anda sendiri. Cobalah atau berpikir tentang lainnya hal yang bisa menampilkan menggunakan beberapa LED. • Menggunakan tombol untuk melempar dadu tampaknya sedikit canggung, bukan? Biasanya, Anda mengambil dadu ke kedua tangan dan kocok mereka. Anda dapat mudah mensimulasikan bahwa dengan sensor kemiringan. Sensor kemiringan mendeteksi tilting dari obyek dan perangkat sempurna untuk mensimulasikan gulungan dadu. Pada prinsipnya, mereka bekerja seperti tombol tekan, tapi Anda tidak menekan mereka - Anda kocok mereka. Cobalah untuk menambahkan satu untuk dadu biner dengan bekerja jalan Anda melalui tutorial pada Situs Arduino.
51
Membuat Morse Code Generator Library Sekarang Anda cukup tahu tentang lingkungan pengembangan Arduino dan sekitar berkedip LED untuk memulai sebuah proyek yang lebih besar. Dalam bab ini, kita akan mengembangkan generator kode Morse yang membaca teks dari port serial dan output sebagai sinyal cahaya menggunakan LED. Dengan membangun proyek ini, Anda akan memperdalam pemahaman Anda tentang seri komunikasi antara Arduino dan komputer Anda. Anda juga akan belajar banyak tentang proses pengembangan khas Arduino : bagaimana menggunakan library yang ada dan bagaimana struktur proyek yang lebih besar ke Anda sendiri library. Pada akhirnya, Anda akan dapat membuat library yang siap penerbitan di Internet.
4.1 Yang Anda Butuhkan • 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 pesan”Hello, 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 #include <WProgram.h> #include”telegraph.h" char* LETTERS[] = { ".-",”-...",”-.-.",”-..",”.", // A-E "..-.",”--.",”....",”..",”.---", // F-J "-.-",”.-..",”--",”-.",”---", // K-O ".--.",”--.-",”.-.",”...",”-", // P-T
55
"..-",”...-",”.--",”-..-",”-.--", // U-Y "--..”//Z }; char* DIGITS[] ={ "-----",”.----",”..---",”...--", // 0-3 "....-",”.....",”-....",”--...", // 4-7 "---..",”----.”// 8-9 }; 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 mengandung”nyata”C + + 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, dunia”Buat baru sketsa bernama HelloWorld, dan masukkan kode berikut ::
#include”telegraph.h" const unsigned int OUTPUT_PIN = 13; const unsigned int DIT_LENGTH = 200; Telegraph telegraph(OUTPUT_PIN, DIT_LENGTH); void setup() {} void loop() { telegraph.send_message("Hello, world!"); delay(5000); }
Sketsa ini memancarkan string”Hello, 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: #include”telegraph.h" const unsigned int OUTPUT_PIN = 13; const unsigned int DIT_LENGTH = 200; const unsigned int MAX_MESSAGE_LEN = 128; const unsigned int BAUD_RATE = 9600; const int LINE_FEED = 13; char message_text[MAX_MESSAGE_LEN]; int index = 0; Telegraph telegraph(OUTPUT_PIN, DIT_LENGTH); void setup(){ Serial.begin(BAUD_RATE); } void loop() { if (Serial.available() > 0){ int current_char = Serial.read(); if (current_char == LINE_FEED || index == MAX_MESSAGE_LEN - 1){ message_text[index] = 0; index = 0; telegraph.send_message(message_text); } else { message_text[index++] = current_char; }
61
} }
Sekali lagi, kita menyertakan file header dari Telegraph kelas, dan seperti yang kita biasa mendefinisikan beberapa konstanta: OUTPUT_PIN mendefinisikan pin LED kita terhubung untuk, dan DIT_LENGTH berisi panjang dari dit diukur dalam milidetik. LINE_FEED diatur ke kode ASCII dari karakter linefeed. Kita membutuhkannya untuk menentukan akhir pesan yang akan dipancarkan sebagai kode Morse. akhirnya, kita set MAX_MESSAGE_LEN dengan panjang maksimum pesan yang kita dapat mengirim.
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 menjadi”blinkenlights.”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 pilih”Carriage return”dari 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.
4.8 Kesalahan-kesalahan yang Mungkin Terjadi 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 (menemukan”Melody”contoh 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.
5.1 Yang Anda Butuhkan 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 6. Sebuah papan Arduino seperti Uno, Duemilanove, atau Diecimila 7. Sebuah kabel USB untuk menghubungkan Arduino ke komputer Anda 8. A 6 pin 0,1”header 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,1”header standar. Sensor memiliki enam konektor berlabel GND, Z, Y, X, 3V, dan UJI. Untuk menggunakan sensor pada papan breadboard, solder Header standar untuk konektor. Hal ini tidak hanya membuat lebih mudah untuk melampirkan sensor untuk papan breadboard tetapi juga menstabilkan sensor, sehingga tidak bergerak secara tidak sengaja. Anda dapat melihat hasilnya di sisi kiri foto (perhatikan bahwa papan breakout di sebelah kiri adalah tidak sama dengan di sebelah kanan, tapi itu sangat mirip). Jangan khawatir jika Anda belum pernah disolder sebelumnya. Anda dapat belajar bagaimana melakukannya. Anda dapat mengabaikan konektor berlabel TEST, dan makna konektor yang tersisa harus jelas. Untuk daya sensor, hubungkan GND ke tanah pin Arduino dan 3V ke Arduino 3,3 volt power supply. X, Y, dan Z kemudian akan mengirimkan data percepatan untuk x -, y -, dan z - sumbu. 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
const unsigned int BAUD_RATE = 9600; void setup(){ Serial.begin(BAUD_RATE); } void loop(){ Serial.print(analogRead(X_AXIS_PIN)); Serial.print(“"); Serial.print(analogRead(Y_AXIS_PIN)); Serial.print(“"); Serial.println(analogRead(Z_AXIS_PIN)); delay(100); }
Program uji kita adalah yang sederhana seperti itu bisa. Kita mendefinisikan konstanta untuk tiga analog pin dan menginisialisasi port serial di setup () function. Perhatikan bahwa kita tidak mengatur pin analog ke INPUT eksplisit, karena itu default pula. Dalam loop () fungsi, kita terus-menerus output nilai-nilai yang kita baca dari pin analog ke port serial. Buka monitor seri, dan bergerak sensor sekitar sedikit-miringkan sekitar sumbu yang berbeda. Anda harus melihat output yang mirip dengan berikut:
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:
const unsigned int X_AXIS_PIN = 2; const unsigned int Y_AXIS_PIN = 1; const unsigned int Z_AXIS_PIN = 0; const unsigned int BAUD_RATE = 9600; int min_x, min_y, min_z; int max_x, max_y, max_z; void setup() { Serial.begin(BAUD_RATE); 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; - const unsigned int BAUD_RATE = 9600; 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 const unsigned int BUTTON_PIN = 7; const unsigned int X_AXIS_PIN = 2; const unsigned int Y_AXIS_PIN = 1; const unsigned int Z_AXIS_PIN = 0; const unsigned int NUM_AXES = 3; const unsigned int PINS[NUM_AXES] ={ X_AXIS_PIN, Y_AXIS_PIN, Z_AXIS_PIN }; const unsigned int BUFFER_SIZE = 16; const unsigned int BAUD_RATE = 19200; int buffer[NUM_AXES][BUFFER_SIZE]; int buffer_pos[NUM_AXES] = { 0 }; Bounce button(BUTTON_PIN, 20); void setup() { Serial.begin(BAUD_RATE); pinMode(BUTTON_PIN, INPUT); } int get_axis(const int axis) { delay(1); buffer[axis][buffer_pos[axis]] = analogRead(PINS[axis]); buffer_pos[axis] = (buffer_pos[axis] + 1) % BUFFER_SIZE; long sum = 0; for (int i = 0; i < BUFFER_SIZE; i++) sum += buffer[axis][i]; return round(sum / BUFFER_SIZE); }
77
int get_x() { return get_axis(0); } int get_y() { return get_axis(1); } int get_z() { return get_axis(2);} void loop() { Serial.print(get_x()); Serial.print(“"); Serial.print(get_y()); Serial.print(“"); Serial.print(get_z()); Serial.print(“"); if (button.update()) Serial.println(button.read() == HIGH ?”1”:”0"); else Serial.println("0"); }
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 mencetak”Anda Menang!”pesan. Jika permainan dihentikan sementara, kita mencetak pesan yang sesuai, dan jika tidak, kita memperbarui kondisi permainan saat ini. Akhirnya, kita menarik bola dan mendayung di posisi mereka saat menggunakan fungsi-fungsi berikut:
boolean drawBricks() { boolean allEmpty = true; for (int x = 0; x < COLUMNS; x++){ for (int y = 0; y < ROWS; y++) { if (bricks[x][y] > 0){ allEmpty = false; fill(0, 0, 100 + y * 8); rect( MARGIN + x * BRICK_WIDTH, MARGIN + y * BRICK_HEIGHT, BRICK_WIDTH, BRICK_HEIGHT ); } } } return allEmpty; } void drawBall() { strokeWeight(1); fill(128, 0, 0); ellipse(px, py, BALL_DIAMETER, BALL_DIAMETER); } void drawPaddle() { int x = xpos - PADDLE_WIDTH / 2; int y = height - (PADDLE_HEIGHT + MARGIN); strokeWeight(1);
83
fill(128); rect(x, y, PADDLE_WIDTH, PADDLE_HEIGHT); }
Seperti yang Anda lihat, bola tidak lain adalah lingkaran, dan batu bata dan dayung adalah persegi panjang sederhana. Untuk membuat mereka terlihat lebih menarik, kita memberi mereka perbatasan bagus. Mencetak pesan permainan mudah, juga:
void printWinMessage() { fill(255); textSize(36); textAlign(CENTER); text("YOU WIN!", width / 2, height * 2 / 3); } void printPauseMessage() { fill(128); textSize(16); textAlign(CENTER); text("Press Button to Continue", width / 2, height * 5 / 6); }
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 cetak”Game Over”pesan ketika counter mencapai nol. Jika bola masih dalam bermain, kita memeriksa untuk berbagai tabrakan. Kita memeriksa apakah bola telah mencapai satu atau lebih batu bata, jika telah menabrak dinding, atau jika telah memukul dayung. Kemudian kita menghitung posisi baru bola. Pemeriksaan tabrakan terlihat rumit, tetapi mereka cukup sederhana dan hanya membandingkan bola berkoordinasi dengan koordinat semua benda lain pada layar:
boolean ballDropped() { return py + vy > height - BALL_RADIUS; } boolean inXRange(final int row, final int v) { return px + v > row * BRICK_WIDTH && px + v < (row + 1) * BRICK_WIDTH + BALL_DIAMETER; } boolean inYRange(final int col, final int v) { return py + v > col * BRICK_HEIGHT && py + v < (col + 1) * BRICK_HEIGHT + BALL_DIAMETER; } void checkBrickCollision() { for (int x = 0; x < COLUMNS; x++){ for (int y = 0; y < ROWS; y++) { if (bricks[x][y] > 0){
85
if (inXRange(x, vx) && inYRange(y, vy)) { bricks[x][y] = 0; if (inXRange(x, 0)) // Hit top or bottom of brick. vy = -vy; if (inYRange(y, 0)) // Hit left or right side of brick. vx = -vx; } } } } } void checkWallCollision() { if (px + vx < BALL_RADIUS || px + vx > width - BALL_RADIUS) vx = -vx; if (py + vy < BALL_RADIUS || py + vy > height - BALL_RADIUS) vy = -vy; } void checkPaddleCollision() { final int cx = xpos; if (py + vy >= height - (PADDLE_HEIGHT + MARGIN + 6) && px >= cx - PADDLE_WIDTH / 2 && px <= cx + PADDLE_WIDTH / 2) { vy = -vy; vx = int( map( px - cx, -(PADDLE_WIDTH / 2), PADDLE_WIDTH / 2, -MAX_VELOCITY, MAX_VELOCITY ) );
86
} }
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.
6.8 Kesalahan-kesalahan yang Mungkin Terjadi 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 dengan”telanjang”Arduino 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
6.1 Yang Anda Butuhkan 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. Sebuah papan Arduino seperti Uno, Duemilanove, atau Diecimila 7. Sebuah kabel USB untuk menghubungkan Arduino ke komputer Anda
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; - const unsigned int BAUD_RATE = 9600; 5 const float SUPPLY_VOLTAGE = 5.0;
91
- void setup(){ - Serial.begin(BAUD_RATE); -} 10 - void loop(){ - const int sensor_voltage = analogRead(TEMP_SENSOR_PIN); - const float voltage = sensor_voltage * SUPPLY_VOLTAGE / 1024; - const float celsius = (voltage * 1000 - 500) / 10; 15 #ifdef CELSIUS - Serial.print(celsius); - Serial.println(“C"); - #else - Serial.print(9.0 / 5.0 * celsius + 32.0); 20 Serial.println(“F"); - #endif - delay(5000); -}
Ini hampir sketsa yang sama kita telah digunakan sebelumnya. Perlu diingat bahwa Anda harus menetapkan SUPPLY_VOLTAGE menjadi 3,3 di baris 5, jika Anda menggunakan Arduino yang berjalan dengan 3.3V bukan 5V. Kita mendukung baik Celcius dan Fahrenheit nilai sekarang, dan Anda dapat mengontrol Unit yang harus digunakan dengan konstanta preprocessor. Jika Anda mengatur yang CELSIUS konstan dalam baris pertama, aplikasi output suhu dalam derajat Celcius. Jika Anda menghapus baris pertama atau mengubahnya menjadi baris komentar, Fahrenheit akan digunakan. Untuk mengubah perilaku aplikasi, kita menggunakan preprocessor # ifdef direktif. Ia memeriksa apakah preprocessor konstan tertentu telah mengatur, dan kemudian mengkompilasi kode kondisional. Dalam kasus kita, itu akan mengkompilasi Celcius - to- Fahrenheit rumus di baris
92
19 hanya jika CELSIUS konstan belum ditetapkan. Upload sketsa, dan itu akan menampilkan suhu saat ini ke port serial setiap lima detik. Outputnya terlihat sebagai berikut :
27.15C 26.66C 27.15C Yang kita butuhkan sekarang adalah sebuah program yang berjalan pada PC Anda yang membaca ini output dan tweet pesan segera karena suhu lebih besar dari 32 derajat Celcius ( 90 derajat Fahrenheit ). Kita bisa menggunakan bahasa pemrograman yang mampu membaca dari port serial dan yang mendukung Twitter, tetapi karena kita telah menggunakan Processing dalam semua lainnya contoh, kita akan menggunakannya untuk proyek ini juga.
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, klik”Daftar aplikasi”link, 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 =“"; final String CONSUMER_SECRET =“"; final String ACCESS_TOKEN =“"; final String 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 kita”Bawa saya ke beach”alarm : 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 lebih”resmi”perisai, 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
Serial.begin(BAUD_RATE); } //...
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: <[email protected]> ) 250 2.1.0 OK q43si10820020eeh.100 ( RCPT TO: ) 250 2.1.5 OK q43si10820020eeh.100 ( DATA ) 354 Go ahead q43si10820020eeh.100 ( from: [email protected]
105
( to: [email protected] ( 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 atribut”dari”,”untuk”, dan”subjek,”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_ - #include”email.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> - #include”smtp_service.h" 5 const unsigned int SMTP_PORT = 25; - const unsigned int BAUD_RATE = 9600; - 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); - Serial.begin(BAUD_RATE); - delay(1000); 20 Email email( -”[email protected]", -”[email protected]",
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; - const unsigned int BAUD_RATE = 9600; - 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(){ - Serial.begin(BAUD_RATE);
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__ - #include”pir_sensor.h" 5 #include”smtp_service.h" - class BurglarAlarm{ - PassiveInfraredSensor _pir_sensor; - SmtpService _smtp_service; 10 - void send_alarm(){ - Email email( -”[email protected]", -”[email protected]", 15”Intruder 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> #include”burglar_alarm.h" const unsigned int PIR_INPUT_PIN = 2; const unsigned int SMTP_PORT = 25; const unsigned int BAUD_RATE = 9600; byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
116
byte my_ip[] = { 192, 168, 2, 120 }; // Insert IP of your SMTP server below! byte smtp_server[] = { 0, 0, 0, 0 }; PassiveInfraredSensor pir_sensor(PIR_INPUT_PIN); SmtpService smtp_service(smtp_server, SMTP_PORT); BurglarAlarm burglar_alarm(pir_sensor, smtp_service); void setup(){ Ethernet.begin(mac, my_ip); Serial.begin(BAUD_RATE); delay(20 * 1000); } void loop() { burglar_alarm.check(); delay(3000); }
Pertama kita mendefinisikan semua library yang kita butuhkan, dan kita mendefinisikan konstanta untuk PIR sensor pin dan alamat MAC kita. Kemudian kita mendefinisikan SmtpService dan PassiveInfraredSensor benda dan menggunakannya untuk mendefinisikan sebuah BurglarAlarm misalnya. Dalam metode setup (), kita mendefinisikan port serial dan perisai Ethernet. Saya juga telah menambahkan penundaan dua puluh detik, yang memberikan Anda cukup waktu untuk meninggalkan ruangan sebelum alarm mulai bekerja. Loop ( ) fungsi sederhana, juga. Ini delegasi semua pekerjaan ke Burglar Kita sudah rapi menyembunyikan kompleksitas kedua email dan sensor PIR di dua kelas kecil. Untuk membangun alarm pencuri, kita kemudian hanya harus menulis beberapa kode lem. Satu kata mengenai privasi : tidak menyalahgunakan proyek dalam bab ini untuk mengamati orang lain tanpa sepengetahuan mereka. Tidak hanya itu tidak etis, tetapi di banyak negara bahkan adalah ilegal! Dalam bab ini, Anda belajar cara yang berbeda untuk menghubungkan Arduino ke Internet. Beberapa dari mereka membutuhkan PC tambahan,
117
sementara yang lain perlu perisai Ethernet, tetapi mereka semua membuka pintu untuk berbagai baru dari aplikasi komputasi embedded. Networking adalah salah satu teknik yang mungkin memiliki dampak langsung pada dunia luar. Dalam bab berikutnya, Anda akan belajar tentang yang lain teknik yang memiliki efek yang serupa, Anda akan belajar bagaimana untuk mengontrol perangkat jarak jauh.
6.10 Kesalahan-kesalahan yang Mungkin Terjadi 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. O’Reilly 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
