suryauniv arduino muhammad bangun agung 202136575862733

8/20/2019 SuryaUniv Arduino Muhammad Bangun Agung 202136575862733

1/126

17 Maret 2014

M.BANGUN

AGUNG ARDUINO FOR BEGINNERS


2/126

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.


3/126

ii

Daftar Isi

Kata Pengantar ......................................................................................................... iDaftar 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


4/126

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


5/126

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.


6/126

2

Bab 1

Mengenal Arduino


7/126

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.


8/126

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.


9/126

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.


10/126

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)


11/126

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


12/126

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.


13/126

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


14/126

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


15/126

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.


16/126

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

- }


17/126

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


18/126

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.


19/126

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


20/126

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.


21/126

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


22/126

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.


23/126

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.


24/126

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)


25/126

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


26/126

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


27/126

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


28/126

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


29/126

25

yang kita butuhkan untuk mengirim dan menerima data melalui port serial di kita

Program.

Mari kita membaca dan menafsirkan data. Loop () fungsi dimulai denganmemanggil 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.


30/126

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,


31/126

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


32/126

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.


33/126

29

2.5 Kesalahan-kesalahan yang Mungkin Terjadi

Jika Anda masih mengalami masalah, mungkin karena beberapa masalah

dengan komunikasi serial. Sebagai contoh, Anda mungkin telah mengatur baud

yang salah tingkat.

Pastikan bahwa baud rate yang telah ditetapkan dalam ajakan Anda untuk

Serial.begin () sesuai dengan baud rate pada monitor serial.

2.6 Latihan

• Tambahkan perintah baru untuk program sampel. Sebagai contoh, perintah 3

bisa membuat LED berkedip untuk sementara waktu.

• Cobalah untuk membuat perintah lebih mudah dibaca. Misalnya ketika di atas

Anda menuliskan 1, gantilah dengan on, dan ketika Anda menuliskan 2, gantilahdengan off off.


34/126

30


35/126

31

Bab 2

Proyek-proyek

Arduino


36/126

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.

3.1 Yang Anda Butuhkan

1. Setengah - ukuran papan tempat breadboard

2. Tiga LED (untuk latihan Anda harus LED tambahan)

3. Dua 10k resistor


37/126

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


38/126

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


39/126

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


40/126

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



41/126

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


42/126

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 statisdan 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);


43/126

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;


44/126

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


45/126

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


46/126

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(){

- const int CURRENT_BUTTON_STATE = digitalRead(BUTTON_PIN);- if (CURRENT_BUTTON_STATE!= old_button_state &&

15 CURRENT_BUTTON_STATE == HIGH)

- {

- led_state = (led_state == LOW) ? HIGH : LOW;


- delay(50);

20 }


47/126

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:

const unsigned int LED_BIT0 = 12;

const unsigned int LED_BIT1 = 11;const unsigned int LED_BIT2 = 10;


void setup() {

pinMode(LED_BIT0, OUTPUT);





48/126

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(){

- const int CURRENT_BUTTON_STATE = digitalRead(BUTTON_PIN);

- if (CURRENT_BUTTON_STATE!= old_button_state &&

15 CURRENT_BUTTON_STATE == HIGH)

- {

- led_state = (led_state == LOW) ? HIGH : LOW;


- 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


49/126

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


50/126

46

salahnya untuk membaca petunjuk instalasi dan dokumentasi di halaman web.

Berikut versi final dari kode biner dadu kita:

#include

-



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();

- }

-


51/126

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 }

-


52/126

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