ARDUINO UNTUK PEMULA

17 Maret 2014
M.BANGUN
AGUNG
ARDUINO FOR BEGINNERS

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

ii
Daftar Isi
Kata Pengantar ......................................................................................................... i
Daftar Isi ................................................................................................................. ii
Pendahuluan............................................................................................................ 1
Bab 1 Mengenal Arduino........................................................................................ 2
1.1 Apakah Arduino itu?......................................................................................... 3
1.2 Yang Anda butuhkan ........................................................................................ 5
1.3 Instalasi Arduino IDE ....................................................................................... 8
Instalasi Arduino IDE pada Windows................................................................. 9
Instalasi Arduino IDE pada Mac OS X............................................................... 9
Instalasi Arduino IDE di Linux......................................................................... 10
1.4 Arduino IDE.................................................................................................... 10
1.5 Tipe-tipe Data dalam Arduino ........................................................................ 13
1.6 Kompilasi dan Program Uploading................................................................. 15
1.7 LED................................................................................................................. 17
1.8 Kesalahan-kesalahan yang Mungkin Terjadi.................................................. 18
1.9 Latihan ............................................................................................................ 19
2.1 Yang Anda Butuhkan...................................................................................... 20
2.2 Mengelola Proyek dan Sketsa......................................................................... 21
2.3 Mengubah Preferensi ...................................................................................... 22
2.4 Menggunakan Port Serial................................................................................ 23
2.6 Latihan ............................................................................................................ 29
Bab 2 Proyek-proyek Arduino .............................................................................. 31
3.2 Breadboards .................................................................................................... 33
3.3 Menggunakan LED pada Breadboard............................................................. 34
3.4 Dice Binary ..................................................................................................... 35
3.5 Tombol-tombol yang Ada............................................................................... 38
3.6 Menambahkan Tombol ................................................................................... 43
3.7 Membuat Permainan Dadu.............................................................................. 45

iii
3.9 Latihan ............................................................................................................ 50
4.2 Mempelajari Dasar-dasar dari Kode Morse.................................................... 52
4.3 Membuat Morse Code Generator.................................................................... 53
4.4 Interface Generator.......................................................................................... 55
4.5 Output Simbol Kode Morse ............................................................................ 57
4.6 Memasang dan Menggunakan Class Telegraph.............................................. 59
4.7 Sentuhan Akhir ............................................................................................... 63
4.9 Latihan ............................................................................................................ 65
5.2 Accelerometer ................................................................................................. 69
5.3 Menghidupkan Accelerometer........................................................................ 70
5.5 Kontroler dan Game........................................................................................ 76
5.6 Membuat Game Sendiri .................................................................................. 79
6.7 Aplikasi Proyek............................................................................................... 88
6.9 Latihan ............................................................................................................ 89
6.2 PC Transfer Sensor data ke Internet................................................................ 91
6.3 Mendaftarkan Aplikasi di Twitter................................................................... 93
6.4 Tweeting Pesan dengan Processing ................................................................ 94
6.5 Berkomunikasi Menggunakan Perisai Ethernet.............................................. 98
6.6 Emailing dari Command Line....................................................................... 104
6.7 Emailing Langsung dari Arduino.................................................................. 107
6.8 Mendeteksi Gerak Menggunakan Passive Infrared Sensor........................... 112
6.9 Menyatukan Semuanya................................................................................. 115
6.10 Kesalahan-kesalahan yang Mungkin Terjadi.............................................. 118
6.11 Latihan ........................................................................................................ 119
Daftar Pustaka......................................................................................................cxx
Lampiran ........................................................................................................... cxxii

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

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

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

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

6
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
Konektor USB
Power Plug
Pins Digital I/O
Tombol Reset
Mikrokontroler
Pin Analog InputPower Supply
Gambar 1.2. Bagian-bagian Arduino (Diecimila).
Jumper
(khusus untuk
beberapa
jenis Arduino)

7
hanya memberikan 5 volt, dan kadang-kadang Anda membutuhkan lebih banyak
daya.
Dalam situasi ini, solusi terbaik biasanya adalah adaptor AC yang
memberikan tegangan 9V (kisaran yang direkomendasikan adalah 7V untuk 12V).
Anda membutuhkan adaptor dengan ujung laras 2,1 mm dan pusat positif
(tanyakan kepada orang yang menjualnya). Tancapkan ke power plug Arduino,
dan Arduino bisa segera dinyalakan, bahkan ketika tidak terhubung ke komputer.
Dengan cara itu, jika Anda menghubungkan Arduino ke port USB, Arduino akan
menggunakan daya eksternal jika tersedia.
Harap diperhatikan bahwa beberapa versi papan Arduino seperti Arduino-
NG dan Diecimila tidak beralih secara otomatis antara daya eksternal dan pasokan
USB. Mereka dirancang dengan jumper seleksi listrik (lihat gambar 1.2) berlabel
PWR_SEL dan Anda harus mengaturnya secara manual untuk masing-masing
EXT atau USB.
Sekarang Anda telah mengetahui dua cara untuk menyalurkan daya ke
Arduino. Ketika Arduino dihubungkan dengan komputer Anda, Arduino tidak
mengambil semua daya yang ada, namun Arduino juga membagin daya tersebut
dengan perangkat lain. Pada bagian gambar 1.2, pada halaman sebelumnya, Anda
dapat melihat beberapa soket (disebut juga dengan pin, karena internal mereka
terhubung ke pin di mikrokontroler) terkait dengan power supply :
• Menggunakan pin berlabel 3V3 dan 5V, Anda dapat daya perangkat eksternal
terhubung ke Arduino dengan 3,3 volt atau 5 volt.
• Dua pin berlabel Gnd memungkinkan yang perangkat eksternal Anda untuk
berbagi kesamaan dengan Arduino.
• Beberapa proyek bersifat portabel, sehingga mereka akan menggunakan pasokan
listrik portabel seperti baterai. Anda menghubungkan sumber daya eksternal
seperti baterai ke Vin dan Gnd soket. Jika Anda menghubungkan adaptor AC ke
colokan (soket) listrik Arduino, Anda dapat menyalurkan tegangan dari adaptor
melalui pin ini.
Pada bagian kanan bawah papan, ada enam pin input analog A0 - A5.
Anda dapat menggunakannya untuk menghubungkan sensor analog ke Arduino.

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

9
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

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

11
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.
Gambar 1.3. Tampilan Arduino IDE.
Verify Stop New Open Save Upload Serial Monitor
Gambar 1.4. Toolbar Arduino IDE.

12
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);
- }

13
Mari kita lihat bagaimana program ini bekerja. Dalam dua baris pertama
kita mendefinisikan dua konstanta int menggunakan const. LED_PIN mengacu
pada jumlah IO pin digital yang digunakan, dan PAUSE mendefinisikan jumlah
waktu yang diperlukan setiap LED berkedip dalam milidetik.
Setiap program Arduino membutuhkan fungsi bernama setup(). Sebuah
definisi fungsi selalu mematuhi skema berikut :
Nilai <return data> <function name ' (' <list dari parameters> ') '
Dalam kasus ini, nama fungsinya adalah setup (), dan jenis nilai
kembalinya kosong membatalkan : ia tidak mengembalikan apa-apa. setup() tidak
mengharapkan adanya argumen, jadi parameternya juga kosong. Sebelum kita
membahas program tersebut lebih jauh, Anda perlu mengetahui tipe-tipe data
yang terdapat pada Arduino.
1.5 Tipe-tipe Data dalam Arduino
Setiap bagian dari data yang Anda simpan dalam program Arduino
memiliki tipe datanya masing-masing.
Tergantung pada kebutuhan Anda, Anda dapat memilih dari tipe-tipe data berikut
ini :
• Tipe data boolean mengambil satu byte memori dan dapat bernilai benar atau
salah.
• Tipe data char mengambil satu byte nomor memori dan menyimpan dari -128
sampai 127. Angka-angka ini biasanya mewakili karakter yang dikodekan dalam
ASCII.

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

15
• 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

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

17
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

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

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

20
Bagian Dalam Arduino
Untuk aplikasi sederhana, semua yang Anda telah belajar tentang Arduino
IDE di bab sebelumnya sudah cukup. Tapi segera proyek Anda akan mendapatkan
lebih banyak ambisius, dan kemudian akan berguna untuk membagi mereka
menjadi terpisah file yang dapat Anda mengelola secara keseluruhan. Jadi dalam
bab ini, Anda akan belajar bagaimana untuk tetap dalam kontrol atas proyek-
proyek besar dengan Arduino IDE.
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)

21
2.2 Mengelola Proyek dan Sketsa
Pengembang perangkat lunak modern dapat memilih dari berbagai
pengembangan alat-alat yang mengotomatisasi tugas yang berulang dan
membosankan. Itu juga berlaku untuk embedded system seperti Arduino. Anda
dapat menggunakan pengembangan terpadu lingkungan (IDE) untuk mengelola
program Anda, juga. yang paling salah satu yang populer telah dibuat oleh tim
Arduino. Arduino IDE mengelola semua file milik proyek Anda. Hal ini juga
memberikan akses mudah ke semua alat yang Anda butuhkan untuk menciptakan
binari yang akan berjalan di papan Arduino Anda. Mudah, ia melakukannya diam-
diam.
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

22
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

23
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

24
menekan 1, dan itu harus berubah off ketika Anda menekan 2. Berikut semua
kode yang kita butuhkan :
Line 1 const unsigned int LED_PIN = 13;
- const unsigned int BAUD_RATE = 9600;
-
- void setup(){
- Serial.begin(BAUD_RATE);
- }
-
- void loop(){
10 if (Serial.available() > 0){
- int command = Serial.read();
- if (command == '1'){
- digitalWrite(LED_PIN, HIGH);
- Serial.println("LED on");
15 } else if (command == '2'){
- digitalWrite(LED_PIN, LOW);
- Serial.println("LED off");
- } else{
- Serial.print("Unknown command:”);
20 Serial.println(command);
- }
- }
- }
Seperti pada contoh sebelumnya, kita mendefinisikan sebuah konstanta
untuk pin LED terhubung ke dan set ke modus OUTPUT di setup () function. di
line 6, kita menginisialisasi port serial menggunakan mulai () fungsi dari Serial
kelas, melewati baud rate 9600 (Anda dapat mempelajari apa baud rate dalam
Bagian C.1, Belajar More About Serial Komunikasi, pada halaman 251). Itu saja

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

26
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,

27
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

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

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

31
Bab 2
Proyek-proyek
Arduino

32
Membuat Arduino
Binary Dice
Hal yang benar-benar akan mulai mendapatkan menarik sekarang bahwa
Anda telah belajar dasar-dasar pengembangan Arduino. Anda sekarang memiliki
kemampuan untuk membuat Anda kompleks pertama, proyek yang berdiri sendiri.
Setelah Anda telah bekerja melalui ini bab, Anda akan tahu bagaimana bekerja
dengan LED, tombol, breadboards, dan resistor. Menggabungkan bagian ini
dengan Arduino memberi Anda hampir kesempatan tak terbatas untuk proyek-
proyek baru dan keren. Proyek pertama kita akan membuat mati elektronik.
Sementara dadu biasa menampilkan hasil mereka menggunakan 1-6 titik, kita
akan menggunakan LED sebagai gantinya.
Untuk percobaan pertama kita, sebuah LED tunggal telah cukup, tetapi
untuk dadu kita membutuhkan lebih dari satu. Anda perlu untuk menghubungkan
beberapa eksternal LED untuk Arduino. Karena Anda tidak dapat melampirkan
mereka semua langsung ke Arduino, Anda akan belajar bagaimana bekerja dengan
breadboards. Juga, Anda perlu tombol yang gulungan dadu, sehingga Anda akan
belajar bagaimana bekerja dengan pushbuttons, juga. Untuk menghubungkan
tombol tekan dan LED untuk Arduino, Anda perlu penting lainnya elektronik
bagian : resistor. Jadi, pada akhir bab, Anda akan memiliki banyak alat-alat baru
dalam kotak peralatan Anda.
1. Setengah - ukuran papan tempat breadboard
2. Tiga LED (untuk latihan Anda harus LED tambahan)
3. Dua 10k resistor

33
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

34
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

35
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

36
langsung. tapi kita perlu tanah untuk tiga LED sekarang, jadi kita akan
menggunakan baris papan tempat breadboard itu untuk pertama kalinya.
Hubungkan baris ditandai dengan tanda hubung (-) untuk Arduino ground
pin, dan semua soket berturut-turut ini akan bekerja sebagai tanah pin, juga.
Kemudian Anda dapat menghubungkan soket ini baris untuk LED menggunakan
kabel pendek. Segala sesuatu yang lain di sirkuit ini harus tampak akrab, karena
kita hanya memiliki untuk mengkloning sirkuit LED dasar dari bagian
sebelumnya tiga kali.
Perhatikan bahwa kita telah menghubungkan tiga sirkuit ke pin 10, 11, dan
12. Satu-satunya hal yang hilang adalah beberapa perangkat lunak :
const unsigned int LED_BIT0 = 12;
- const unsigned int LED_BIT1 = 11;
-
5 void setup(){
- pinMode(LED_BIT0, OUTPUT);
-
10 randomSeed(analogRead(A0));
- long result = random(1, 7);
- output_result(result);
- }
-
15 void loop(){
- }
-
- void output_result(const long result){
- digitalWrite(LED_BIT0, result & B001);
20 digitalWrite(LED_BIT1, result & B010);

37
- }
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

38
dapat membangun, dan untuk prototipe pertama, ini adalah OK. Tetapi sering
Anda membutuhkan lebih dari satu tombol, dan juga lebih elegan untuk
menambahkan tombol Anda sendiri anyway. Jadi, itulah yang akan kita lakukan
pada bagian berikutnya.
3.5 Tombol-tombol yang Ada
Pada bagian ini, kita akan menambahkan tombol tekan kita sendiri untuk
dadu biner kita, sehingga kita tidak lagi harus penyalahgunaan tombol reset
Arduino untuk melempar dadu. Kita akan memulai dari yang kecil dan
membangun sebuah sirkuit yang menggunakan tombol tekan untuk mengontrol
LED tunggal. Jadi, apa sebenarnya tombol tekan (pushbuttons)?
Berikut adalah tiga pandangan khas tombol tekan yang dapat digunakan
sebagai tombol reset Arduino itu. Terhubung Terhubung Top Front Side Ia
memiliki empat konektor yang sangat pas pada papan tempat breadboard
(setidaknya setelah Anda telah meluruskan mereka dengan tang). Dua berlawanan
pin terhubung saat tombol ditekan, jika tidak, mereka terputus. Pada Hubungkan
pin 7 (dipilih secara acak) ke tombol tekan, dan menghubungkan tombol tekan
melalui 10k resistor ke ground pin. Kemudian hubungkan power supply 5 volt ke
pin lain dari tombol. Semua dalam semua, pendekatan ini tampaknya mudah, tapi
mengapa kita perlu resistor lagi?
Masalahnya adalah bahwa kita mengharapkan tombol tekan untuk kembali
nilai default (LOW) dalam kasus ini tidak ditekan. Tapi ketika tombol tidak
ditekan, tidak akan langsung terhubung ke tanah dan akan berkedip karena statis
dan gangguan. Sedikit arus mengalir melalui resistor, dan ini membantu
mencegah gangguan acak dari mengubah tegangan bahwa pin input melihat.
const unsigned int BUTTON_PIN = 7;
void setup() {
pinMode(LED_PIN, OUTPUT);

39
pinMode(BUTTON_PIN, INPUT);
}
void loop() {
const int BUTTON_STATE = digitalRead(BUTTON_PIN);
if (BUTTON_STATE == HIGH)
digitalWrite(LED_PIN, HIGH);
else
digitalWrite(LED_PIN, LOW);
}
Kita menghubungkan tombol ke pin 7 dan LED untuk pin 13 dan
menginisialisasi pin sesuai pada setup () function. Dalam loop (), kita membaca
saat ini keadaan pin yang terhubung ke tombol. Jika TINGGI, kita beralih LED
on. Jika tidak, kita mematikannya. Meng-upload program ke Arduino, dan Anda
akan melihat bahwa LED adalah pada selama Anda menekan tombol. Segera
setelah Anda melepaskan tombol, LED akan mati.
Ini sangat keren, karena sekarang kita hampir memiliki semua yang kita
butuhkan untuk mengendalikan dadu kita menggunakan tombol kita sendiri. tapi
sebelum kita lanjutkan, kita akan sedikit meningkatkan contoh kita dan
mengubah tombol menjadi tombol lampu nyata. Untuk membangun sebuah
lampu, kita mulai dengan solusi yang paling sederhana mungkin. Jangan
mengubah arus hubung, dan meng-upload program berikut untuk Arduino Anda :
- const unsigned int LED_PIN = 13;
-
- void setup(){
- pinMode(BUTTON_PIN, INPUT);
- }
-
- int led_state = LOW;

40
10
- void loop(){
- const int CURRENT_BUTTON_STATE = digitalRead(BUTTON_PIN);
-
- if (CURRENT_BUTTON_STATE == HIGH){
15 led_state = (led_state == LOW) ? HIGH : LOW;
- digitalWrite(LED_PIN, led_state);
- }
- }
Kita mulai dengan biasa pin konstanta, dan di setup () kita tentukan mode
pin yang kita gunakan. Sejalan 9, kita mendefinisikan variabel bernama led_state
global yang untuk menyimpan kondisi saat LED kita. Ini akan menjadi LOW
ketika LED adalah dan TINGGI sebaliknya. Dalam loop (), kita cek negara
tombol saat ini. Ketika kita menekan tombol, negara yang beralih ke TINGGI, dan
kita mengaktifkan isi led_state.
Artinya, jika led_state adalah TINGGI, kita set ke LOW, dan sebaliknya.
Pada akhirnya, kita mengatur negara LED fisik untuk saat ini kita state perangkat
lunak yang sesuai. Solusi kita adalah benar-benar sederhana, tapi sayangnya, tidak
bekerja. Putar main dengan itu sedikit, dan Anda akan segera melihat beberapa
perilaku yang mengganggu.
Jika Anda menekan tombol, misalnya, kadang-kadang LED akan menyala
dan kemudian pergi dengan segera. Juga, jika Anda melepaskannya, LED akan
sering tetap berada dalam keadaan kurang lebih sewenang-wenang, yaitu, kadang-
kadang akan berada di dan kadang-kadang off. Masalahnya adalah bahwa Arduino
mengeksekusi loop (metode) dan lebih lagi. Meskipun CPU Arduino adalah relatif
lambat, ini akan terjadi sangat sering tidak peduli apakah kita saat ini tekan
tombol atau tidak.
Tetapi jika Anda tekan dan tekan terus, negaranya akan terus menjadi
TINGGI, dan Anda akan terus-menerus beralih negara LED (karena ini terjadi
begitu cepat sepertinya LED terus-menerus). Ketika Anda melepaskan tombol,
LED berada dalam keadaan yang lebih atau kurang sewenang-wenang. Untuk

41
memperbaiki situasi, kita harus menyimpan tidak hanya saat LED negara tetapi
juga keadaan sebelumnya tombol tekan ini :
void setup() {
pinMode(LED_PIN, OUTPUT);
}
int old_button_state = LOW;
int led_state = LOW;
void loop() {
const int CURRENT_BUTTON_STATE = digitalRead(BUTTON_PIN);
if (CURRENT_BUTTON_STATE!= old_button_state &&
CURRENT_BUTTON_STATE == HIGH)
{
led_state = (led_state == LOW) ? HIGH : LOW;
digitalWrite(LED_PIN, led_state);
}
old_button_state = CURRENT_BUTTON_STATE;
}
Setelah inisialisasi tombol dan pin LED, kita mendeklarasikan dua
variabel sekarang: toko old_button_state keadaan sebelumnya tombol tekan kita,
dan led_state menyimpan negara LED saat ini. Keduanya dapat berupa TINGGI
atau RENDAH. Dalam loop () fungsi, kita masih harus membaca tombol negara
saat ini, tapi sekarang kita tidak hanya memeriksa apakah TINGGI. Kita juga
memeriksa apakah itu telah berubah sejak terakhir kali kita membacanya. Hanya
ketika kedua kondisi terpenuhi kita beralih negara LED. Jadi, kita tidak lagi
menyalakan LED dan mematikan berulang-ulang selama tombol ditekan.
Di akhir program kita, kita harus menyimpan kondisi tombol saat di
old_button_state. Upload versi baru kita, dan Anda akan melihat bahwa solusi ini

42
bekerja jauh lebih baik dari yang lama kita. Tapi Anda masih akan menemukan
beberapa kasus tepi ketika tombol tidak sepenuhnya berperilaku seperti yang
diharapkan. Masalah terutama terjadi pada saat Anda melepas tombol. Penyebab
masalah ini adalah bahwa tombol mekanik bangkit untuk beberapa milidetik
ketika Anda menekan mereka.
Tepat setelah Anda memiliki menekan tombol, Arduino tidak
memancarkan sinyal yang jelas. Untuk mengatasi hal ini Akibatnya, Anda harus
menghilangkan bounce tombol. Ini biasanya cukup untuk menunggu periode
singkat waktu sampai sinyal tombol yang stabil. debouncing memastikan bahwa
kita bereaksi hanya sekali untuk menekan tombol. tambahan untuk debouncing,
kita masih harus menyimpan keadaan saat ini LED dalam variabel. Berikut adalah
cara untuk melakukannya:
- const unsigned int LED_PIN = 13;
-
- void setup(){
- pinMode(BUTTON_PIN, INPUT);
- }
-
- int old_button_state = LOW;
10 int led_state = LOW;
- void loop(){
- if (CURRENT_BUTTON_STATE!= old_button_state &&
15 CURRENT_BUTTON_STATE == HIGH)
- {
- led_state = (led_state == LOW) ? HIGH : LOW;
- delay(50);
20 }

43
- old_button_state = CURRENT_BUTTON_STATE;
- }
Ini versi final switch LED kita berbeda dari yang sebelumnya di hanya
satu baris: untuk menghilangkan bounce tombol, kita tunggu 50 milidetik sejalan
19 sebelum kita memasuki loop utama lagi. Ini adalah segalanya yang perlu Anda
ketahui tentang tombol tekan untuk saat ini. dalam bagian berikutnya, kita akan
menggunakan dua tombol untuk mengubah dadu biner kita menjadi nyata game.
3.6 Menambahkan Tombol
Sampai sekarang, kita harus penyalahgunaan tombol reset Arduino untuk
mengontrol dadu. Solusi ini jauh dari optimal, jadi kita akan menambahkan
tombol kita sendiri. Kita perlu mengubah kita saat ini sirkuit hanya sedikit.
Sebenarnya, kita tidak perlu mengubah yang sudah ada bagian sama sekali, kita
hanya perlu menambahkan beberapa hal. Pertama kita pasang tombol ke papan
tempat breadboard dan menghubungkannya ke pin 7.
Kemudian kita menghubungkan tombol ke tanah melalui sebuah 10k
resistor dan menggunakan sepotong kecil kawat menghubungkannya ke 5 volt
pin. Itu semua hardware yang kita butuhkan. Berikut perangkat lunak yang
sesuai:
void setup() {
pinMode(LED_BIT0, OUTPUT);

44
randomSeed(analogRead(A0));
}
int current_value = 0;
int old_value = 0;
void loop() {
current_value = digitalRead(BUTTON_PIN);
if (current_value!= old_value && current_value == HIGH){
output_result(random(1, 7));
delay(50);
}
old_value = current_value;
}
void output_result(const long result) {
digitalWrite(LED_BIT0, result & B001);
}
- void loop(){
- if (CURRENT_BUTTON_STATE!= old_button_state &&
15 CURRENT_BUTTON_STATE == HIGH)
- {
- led_state = (led_state == LOW) ? HIGH : LOW;
- delay(50);
20 }
- old_button_state = CURRENT_BUTTON_STATE;
- }
Itu gabungan sempurna dari kode asli dan kode yang diperlukan untuk
kontrol tombol debounced. Seperti biasa, kita menginisialisasi semua pin yang
kita gunakan : tiga untuk LED dan satu input pin untuk tombol pin output. Kita

45
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

46
salahnya untuk membaca petunjuk instalasi dan dokumentasi di halaman web.
Berikut versi final dari kode biner dadu kita:
#include <Bounce.h>
-
5 const unsigned int LED_BIT2 = 10;
- const unsigned int START_BUTTON_PIN = 5;
- const unsigned int GUESS_BUTTON_PIN = 7;
- const unsigned int BAUD_RATE = 9600;
-
10 void setup(){
- 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();
- }
-

47
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 }
-

48
- void output_result(const long result){
65 digitalWrite(LED_BIT2, result & B100);
- }
-
- void hooray(){
- for (int i = 0; i < 3; i++){
70 output_result(7);
- delay(500);
- output_result(0);
- delay(500);
- }
75 }
Diakui bahwa banyak kode, tapi kita tahu sebagian besar sudah, dan
bagian-bagian baru cukup mudah. Pada baris pertama, kita termasuk library
Bounce kita akan menggunakan nanti untuk menghilangkan bounce dua tombol
kita. Kemudian kita mendefinisikan konstanta untuk semua pin yang kita
gunakan, dan di setup () metode, kita menginisialisasi semua kita pin dan
mengatur benih acak. Kita juga menginisialisasi port serial, karena kita akan
keluaran beberapa pesan debug. The Bounce library menyatakan kelas bernama
Bounce, dan Anda harus membuat objek Bounce untuk setiap tombol yang ingin
Anda menghilangkan bounce. Itulah yang terjadi di jalur 21 dan 22.
Konstruktor dari kelas Bounce mengharapkan jumlah pin tombol yang
terhubung ke dan menghilangkan bounce yang keterlambatan dalam milidetik.
Akhirnya, kita menyatakan dan menginisialisasi variabel bernama menebak yang
menyimpan dugaan kita saat ini. Our lingkaran () fungsi telah dikurangi menjadi
dua fungsi panggilan. salah satunya adalah bertanggung jawab untuk menangani
tombol menebak dorongan, dan yang lain menangani dorongan dari tombol start.
Dalam handle_guess_button (), kita menggunakan Bounce Class untuk pertama
kalinya.

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

50
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,

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

52
Membuat Morse Code
Generator Library
Sekarang Anda cukup tahu tentang lingkungan pengembangan Arduino
dan sekitar berkedip LED untuk memulai sebuah proyek yang lebih besar. Dalam
bab ini, kita akan mengembangkan generator kode Morse yang membaca teks dari
port serial dan output sebagai sinyal cahaya menggunakan LED. Dengan
membangun proyek ini, Anda akan memperdalam pemahaman Anda tentang seri
komunikasi antara Arduino dan komputer Anda. Anda juga akan belajar banyak
tentang proses pengembangan khas Arduino : bagaimana menggunakan library
yang ada dan bagaimana struktur proyek yang lebih besar ke Anda sendiri library.
Pada akhirnya, Anda akan dapat membuat library yang siap penerbitan di Internet.
• Sebuah papan Arduino seperti Uno, Duemilanove, atau Diecimila
• Kabel USB untuk menghubungkan Arduino ke komputer Anda
• Sebuah LED
• Sebuah speaker atau buzzer (mereka adalah opsional)
4.2 Mempelajari Dasar-dasar dari Kode Morse
Kode Morse diciptakan untuk mengubah teks ke sounds.1 Pada
prinsipnya, bekerja seperti encoding set karakter seperti ASCII. Tapi sementara
ASCII mengkodekan karakter angka, dalam kode Morse mereka urutan titik dan

53
garis (juga disebut dits dan dahs). Dits lebih pendek panjang dari dahs. Sebuah A
dikodekan sebagai · - dan - · adalah Z.
Kode Morse juga menetapkan skema waktu yang mendefinisikan panjang
dits dan dahs. Hal ini juga menentukan berapa lama jeda antara simbol dan kata-
kata harus. Unit dasar kode Morse adalah panjang dit a, dan da h adalah selama
tiga dits. Anda menyisipkan jeda satu dit antara dua simbol, dan Anda
memisahkan dua surat oleh tiga dits. Menyisipkan jeda tujuh dits antara dua kata.
Untuk mengirimkan pesan dikodekan dalam kode Morse, Anda perlu cara
untuk memancarkan sinyal dengan panjang yang berbeda. Pendekatan klasik
adalah dengan menggunakan suara, tetapi kita akan menggunakan LED yang
diaktifkan dan dinonaktifkan untuk jangka waktu yang berbeda-beda dari waktu
ke waktu. Pelaut masih mengirimkan kode Morse menggunakan lampu berkedip.
Mari kita menerapkan kode Morse Generator!
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.

54
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

55
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 <ctype.h>
#include <WProgram.h>
#include”telegraph.h"
char* LETTERS[] = {
".-",”-...",”-.-.",”-..",”.", // A-E
"..-.",”--.",”....",”..",”.---", // F-J
"-.-",”.-..",”--",”-.",”---", // K-O
".--.",”--.-",”.-.",”...",”-", // P-T

56
"..-",”...-",”.--",”-..-",”-.--", // 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 :

57
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(".");

58
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 == ' '){

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

60
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
::
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

61
dalam library, Anda akan diberitahu sekarang. Jika Anda harus memperbaiki
beberapa kesalahan, pastikan Anda mengubah file kode sumber asli Anda. Setelah
Anda tetap kesalahan, salin file ke library folder lagi, dan jangan lupa untuk me-
restart IDE.
Menghidupkan string statis ke dalam kode Morse bagus, tapi tidak akan
menjadi besar jika program kita bisa bekerja untuk string sewenang-wenang? Jadi,
mari kita tambahkan lebih Contoh canggih. Kali ini, kita akan menulis kode yang
bertuliskan pesan dari port serial dan feed mereka ke Telegraph misalnya. Buat
sketsa baru bernama MorseCodeGenerator, dan masukkan kode berikut:
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;
}

62
}
}
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

ARDUINO UNTUK PEMULA

Recommended

Recommended

More Related Content

Similar to ARDUINO UNTUK PEMULA

Similar to ARDUINO UNTUK PEMULA (20)

Recently uploaded

Recently uploaded (20)

ARDUINO UNTUK PEMULA