suryauniv-arduino-muhammad-bangun- agung-202136

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.

2

Bab 1

Mengenal Arduino

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 Input Power 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;


-

10 void setup(){




- pinMode(START_BUTTON_PIN, INPUT);

15 pinMode(GUESS_BUTTON_PIN, INPUT);

- randomSeed(analogRead(A0));


- }

-

20 const unsigned int DEBOUNCE_DELAY = 20;

- Bounce start_button(START_BUTTON_PIN, DEBOUNCE_DELAY);

- Bounce guess_button(GUESS_BUTTON_PIN, DEBOUNCE_DELAY);

- int guess = 0;

-

25 void loop(){

- handle_guess_button();

- handle_start_button();

- }

-

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

63

kita tidak bisa mendapatkan keuntungan dari keuntungan pemrograman

berorientasi objek.

Namun, kita memiliki beberapa hal-hal kecil yang harus dilakukan untuk

mengubah proyek kita menjadi sebuah firstclass library. Baca lebih lanjut tentang

hal ini pada bagian berikutnya.

4.7 Sentuhan Akhir

Salah satu fitur bagus dari Arduino IDE adalah pewarnaan sintaks. kelas

nama, nama fungsi, variabel, dan sebagainya, semua memiliki warna yang

berbeda di editor. Hal ini membuat lebih mudah untuk membaca kode sumber,

dan itu mungkin untuk menambah pewarnaan sintaks untuk library. Anda hanya

perlu menambahkan file bernama keywords.txt untuk proyek Anda :

# Syntax-coloring for the telegraph library

Telegraph KEYWORD1

send_message KEYWORD2

Baris yang dimulai dengan karakter # mengandung komentar dan akan

diabaikan. Garis yang tersisa berisi nama salah satu anggota library dan jenis

anggota. Pisahkan dengan karakter tab. kelas-kelas memiliki tipe KEYWORD1,

sedangkan fungsi memiliki tipe KEYWORD2. untuk konstanta, gunakan

LITERAL1.

Untuk mengaktifkan pewarnaan sintaks untuk library telegraf, copy

keywords.txt untuk folder library, dan restart IDE. Sekarang nama Telegraph

kelas akan oranye, dan send_message () akan berwarna coklat. Sebelum Anda

akhirnya mempublikasikan library Anda, Anda harus menambahkan beberapa hal:

• Menyimpan semua contoh sketsa dalam folder bernama contoh, dan copy ke

folder library.

Setiap contoh sketsa harus mendapatkan sendiri subdirektori dalam folder itu.

64

• Pilih lisensi untuk proyek Anda, dan menyalin istilah ke dalam sebuah file

bernama LICENSE.4 Anda mungkin berpikir ini adalah sedikit di atas untuk

banyak library, tetapi akan memberikan kepercayaan pemirsa potensial Anda.

• Tambahkan petunjuk instalasi dan dokumentasi. Biasanya, pengguna berharap

untuk menemukan dokumentasi dalam sebuah file bernama README, dan

mereka akan mencari instruksi penginstalan dalam sebuah file bernama

INSTALL. anda harus mencoba untuk menginstal library Anda pada banyak

sistem operasi seperti mungkin dan memberikan petunjuk instalasi untuk mereka

semua. Akhirnya, membuat arsip ZIP yang berisi semua file dalam proyek Anda.

pada sebagian besar sistem operasi, itu cukup untuk klik kanan direktori di

Explorer, Finder, atau apa pun yang Anda gunakan dan mengubah direktori ke

arsip ZIP.

Pada sistem Linux dan pada Mac, Anda juga dapat menggunakan salah

satu dari berikut laporan baris perintah untuk membuat sebuah arsip :

maik> zip -r Telegraph Telegraph

maik> tar cfvz Telegraph.tar.gz Telegraph

Perintah pertama menciptakan sebuah file bernama Telegraph.zip, dan

yang kedua satu menciptakan Telegraph.tar.gz. Kedua format yang luas, dan yang

terbaik untuk menawarkan mereka berdua untuk di-download.

Meskipun Anda harus melakukan banyak operasi file manual, itu masih

mudah untuk membuat sebuah library Arduino. Jadi, tidak ada alasan : setiap kali

Anda pikir Anda telah membangun sesuatu yang keren, membuatnya tersedia

untuk publik.

Sampai saat ini proyek-proyek kita telah berkomunikasi dengan dunia luar

menggunakan LED (output) dan tombol tekan (input). Dalam bab berikutnya,

Anda akan belajar bagaimana bekerja dengan perangkat input yang lebih canggih,

seperti ultrasonik sensor. Anda juga akan belajar bagaimana untuk

65

memvisualisasikan data bahwa Arduino mengirimkan untuk program yang

berjalan pada komputer Anda.


Arduino IDE memiliki pendapat yang kuat tentang penamaan file dan

direktori, dan itu dibangun untuk membuat sketsa, bukan library. Jadi, Anda perlu

melakukan beberapa operasi file pengguna untuk mendapatkan segala sesuatu ke

kanan tempat Jika Anda memiliki lebih dari satu versi dari Arduino IDE diinstal,

pastikan bahwa Anda menggunakan folder library yang tepat. Ingat bahwa Anda

harus me-restart IDE sering. Setiap kali Anda mengubah salah satu file milik

library Anda, restart IDE.

Jika pewarnaan sintaks tidak bekerja, pastikan berkas kata kunci Anda

sebenarnya bernama keywords.txt. Periksa ulang jika Anda telah memisahkan

semua benda dan ketik specifier oleh karakter tab! Restart IDE Anda!

4.9 Latihan

• Kode Morse mendukung tidak hanya huruf dan angka. Hal ini juga

mendefinisikan simbol seperti koma. Meningkatkan Telegraph kelas sehingga

mengerti semua karakter dari kode Morse.

• LED bisa digunakan, tetapi ketika kita berpikir tentang kode Morse, kita

biasanya berpikir tentang bunyi suara, sehingga mengganti LED dengan piezo

speaker, yang murah dan mudah digunakan. Mereka memiliki pin ground dan

sinyal pin, jadi menghubungkan tanah pembicara ke tanah Arduino itu, dan

menghubungkan pin sinyal ke Arduino pin 13. Kemudian ganti output_symbol ()

metode dengan kode berikut :

void Telegraph::output_symbol(const int length) {

const int frequency = 131;

66

tone(_output_pin, frequency, length);

}

Ini mengirimkan gelombang persegi ke speaker, dan memainkan nada yang

memiliki frekuensi 131 Hertz (menemukan”Melody”contoh yang datang

dengan Arduino IDE untuk mempelajari lebih lanjut tentang bermain catatan

dengan speaker piezo).

• Meningkatkan desain library untuk membuatnya lebih mudah untuk mendukung

berbagai perangkat output. Sebagai contoh, Anda bisa melewati beberapa jenis

output- Perangkat objek ke Telegraph konstruktor. Kemudian berasal LedDevice

sebuah dan SpeakerDevice dari OutputDevice. Ini bisa terlihat sebagai berikut:

class OutputDevice {

public:

virtual void output_symbol(const int length);

};

class Led : public OutputDevice {

public:

void output_symbol(const int length){

//...

}

};

class Speaker : public OutputDevice {

public:

void output_symbol(const int length){

//...

}

};

Anda dapat menggunakan kelas tersebut seperti ini :

67

Led led;

Speaker speaker;

OutputDevice* led_device = &led;

OutputDevice* speaker_device = &speaker;

led_device->output_symbol(200);

speaker_device->output_symbol(200);

Sisanya terserah Anda.

Cobalah untuk belajar kode Morse. Biarkan orang lain mengetik beberapa

pesan ke terminal serial dan mencoba untuk mengenali apa yang dia dikirim.

68

Membuat sebuah

Motion-sensing Game

Controller

Sangat mengherankan betapa cepatnya kita terbiasa dengan teknologi

baru. Satu dekade lalu, tidak banyak orang akan membayangkan bahwa kita akan

menggunakan perangkat suatu hari nanti untuk diam-diam mengikuti gerakan kita.

Hari ini benar-benar normal bagi kita untuk secara fisik mengubah smartphone

kita ketika kita ingin mengubah dari tampilan tegak ke mendatar. Bahkan anak-

anak kecil secara intuitif tahu bagaimana menggunakan kontroler motion -sensing

untuk konsol video game seperti Nintendo Wii. Anda dapat membangun

perangkat motion -sensing Anda sendiri dengan menggunakan Arduino, dan

dalam bab ini Anda akan belajar bagaimana.

Kita akan bekerja dengan salah satu perangkat motion -sensing yang

paling luas : the accelerometer. Accelerometers mendeteksi gerakan ke segala

arah - mereka pemberitahuan jika Anda memindahkan mereka ke atas, bawah,

maju, mundur, ke kiri, atau hak. Banyak gadget populer seperti iPhone dan

Nintendo Kontroler Wii mengandung accelerometers. Itu sebabnya

accelerometers yang murah.

Baik proyek-proyek yang menyenangkan dan serius bisa mendapatkan

keuntungan dari accelerometers. kapan bekerja dengan komputer Anda, Anda

pasti memikirkan proyek-proyek seperti pengendali permainan atau perangkat

kontrol input lainnya. Tapi Anda juga dapat menggunakan mereka ketika

berolahraga atau untuk mengontrol labirin marmer kehidupan nyata. Anda juga

69

dapat menggunakannya untuk mengukur percepatan lebih atau kurang secara tidak

langsung, misalnya di dalam mobil. Anda akan belajar bagaimana untuk

menginterpretasikan data accelerometer dengan benar dan bagaimana

mendapatkan hasil yang paling akurat. Kemudian Anda akan menggunakan

accelerometer untuk membangun sendiri motion -sensing controller game Anda,

dan Anda akan menerapkan permainan yang menggunakannya.


1. Sebuah papan breadboard setengah ukuran atau-bahkan lebih baik-an

Prototyping Arduino perisai dengan papan breadboard kecil

2. Sebuah accelerometer ADXL335

3. Sebuah tombol tekan

4. Resistor A 10k

5. beberapa kabel



8. A 6 pin 0,1”header standar

5.2 Accelerometer

Ada banyak accelerometers yang berbeda, berbeda terutama dalam jumlah

sumbu spacial mereka mendukung (biasanya dua atau tiga). Kita menggunakan

ADXL335 dari Analog Devices-sangat mudah untuk digunakan dan available.1

luas Pada bagian ini, kita akan menghubungkan ADXL335 ke Arduino dan

menciptakan program demo kecil yang menunjukkan data mentah sensor

memberikan. di saat itu, kita akan memiliki cepat melihat spesifikasi sensor dan

menafsirkan data.

70

Sensor adalah sirkuit terpadu (IC), dan sisanya hanya pembawa untuk

memungkinkan koneksi. Di atas, Anda melihat 6 pin 0,1”header standar. Sensor

memiliki enam konektor berlabel GND, Z, Y, X, 3V, dan UJI. Untuk

menggunakan sensor pada papan breadboard, solder Header standar untuk

konektor. Hal ini tidak hanya membuat lebih mudah untuk melampirkan sensor

untuk papan breadboard tetapi juga menstabilkan sensor, sehingga

tidak bergerak secara tidak sengaja. Anda dapat melihat hasilnya di sisi kiri foto

(perhatikan bahwa papan breakout di sebelah kiri adalah tidak sama dengan di

sebelah kanan, tapi itu sangat mirip). Jangan khawatir jika Anda belum pernah

disolder sebelumnya. Anda dapat belajar bagaimana melakukannya. Anda dapat

mengabaikan konektor berlabel TEST, dan makna konektor yang tersisa harus

jelas. Untuk daya sensor, hubungkan GND ke tanah pin Arduino dan 3V ke

Arduino 3,3 volt power supply. X, Y, dan Z kemudian akan mengirimkan data

percepatan untuk x -, y -, dan z - sumbu.

ADXL335 merupakan perangkat analog : itu memberikan hasil sebagai

tegangan yang harus dikonversi ke nilai-nilai percepatan. Jadi, X, Y, dan Z

konektor harus terhubung ke tiga analog pin pada Arduino. Kita menghubungkan

Z ke analog pin 0, Y ke analog pin 1, dan X ke analog pin 2. Sekarang kita telah

terhubung ADXL335 ke Arduino, mari kita menggunakannya.

5.3 Menghidupkan Accelerometer

Sebuah strategi pragmatis untuk mendapatkan akrab dengan perangkat

baru untuk menghubungkan itu dan melihat data apa yang memberikan. Program

berikut membaca nilai input untuk semua tiga sumbu dan output mereka ke port

serial:

const unsigned int X_AXIS_PIN = 2;

const unsigned int Y_AXIS_PIN = 1;

const unsigned int Z_AXIS_PIN = 0;

71


void setup(){


}

void loop(){

Serial.print(analogRead(X_AXIS_PIN));

Serial.print(“");

Serial.print(analogRead(Y_AXIS_PIN));

Serial.print(“");

Serial.println(analogRead(Z_AXIS_PIN));

delay(100);

}

Program uji kita adalah yang sederhana seperti itu bisa. Kita mendefinisikan

konstanta untuk tiga analog pin dan menginisialisasi port serial di setup ()

function. Perhatikan bahwa kita tidak mengatur pin analog ke INPUT eksplisit,

karena itu default pula. Dalam loop () fungsi, kita terus-menerus output nilai-nilai

yang kita baca dari pin analog ke port serial. Buka monitor seri, dan bergerak

sensor sekitar sedikit-miringkan sekitar sumbu yang berbeda. Anda harus melihat

output yang mirip dengan berikut:

344 331 390

364 276 352

388 286 287

398 314 286

376 332 289

370 336 301

379 338 281

72

Nilai-nilai ini merupakan data yang kita peroleh untuk x-, y-, dan z-sumbu.

kapan Anda memindahkan sensor hanya sekitar sumbu x, misalnya, Anda dapat

melihat bahwa nilai pertama perubahan sesuai. Berlaku juga untuk data banyak

sensor memancarkan, dan accelerometers tidak terkecuali. Mereka sedikit berbeda

dalam nilai-nilai minimum dan maksimum yang mereka hasilkan, dan mereka

sering Jitter sedikit.

Mereka mungkin mengubah nilai output mereka bahkan meskipun Anda

tidak bergerak mereka, atau mereka mungkin tidak mengubah output mereka

nilai-nilai dengan benar. Pada bagian ini, kita akan menentukan minimum sensor

dan nilai maksimum, dan kita akan meratakan jitter. Menemukan nilai-nilai tepi

sensor mudah, tetapi tidak dapat dengan mudah otomatis. Anda harus terus-

menerus membaca output sensor sementara bergerak itu. Berikut adalah program

yang melakukan pekerjaan:





int min_x, min_y, min_z;

int max_x, max_y, max_z;

void setup() {


min_x = min_y = min_z = 1000;

max_x = max_y = max_z = -1000;

}

void loop() {

const int x = analogRead(X_AXIS_PIN);

const int y = analogRead(Y_AXIS_PIN);

const int z = analogRead(Z_AXIS_PIN);

min_x = min(x, min_x); max_x = max(x, max_x);

min_y = min(y, min_y); max_y = max(y, max_y);

min_z = min(z, min_z); max_z = max(z, max_z);

73

Serial.print("x(");

Serial.print(min_x);

Serial.print("/");

Serial.print(max_x);

erial.print("), y(");

Serial.print(min_y);

Serial.print("/");

Serial.print(max_y);

Serial.print("), z(");

Serial.print(min_z);

Serial.print("/");

Serial.print(max_z);

Serial.println(")");

}

Kita mendeklarasikan variabel untuk nilai-nilai minimum dan maksimum

dari ketiga kapak, dan kita menginisialisasi mereka dengan angka yang pasti

keluar dari berbagai sensor (-1000 dan 1000). Dalam loop () fungsi, kita secara

permanen mengukur percepatan semua tiga sumbu dan menyesuaikan minimum

dan nilai maksimum sesuai. Kompilasi dan upload sketsa, kemudian

memindahkan papan breadboard dengan sensor ke segala arah, dan kemudian

miringkan ke segala arah. Pindahkan perlahan-lahan, bergerak cepat, miringkan

perlahan-lahan, dan miring dengan cepat.

Gunakan kabel panjang, dan berhati-hati ketika bergerak dan berputar

papan breadboard sehingga Anda tidak sengaja melonggarkan sambungan.

Setelah beberapa saat nilai-nilai minimum dan maksimum akan menstabilkan, dan

Anda harus mendapatkan output seperti ini : x (247/649), y (253/647), z (278/658)

Tuliskan nilai-nilai ini, karena kita membutuhkannya nanti, dan mungkin Anda

akan membutuhkannya ketika Anda melakukan percobaan sensor sendiri.

Sekarang mari kita lihat bagaimana untuk menyingkirkan jitter. Pada prinsipnya,

itu sederhana. malah kembali data percepatan segera, kita mengumpulkan

74

pembacaan terakhir dan kembali rata-rata mereka. Dengan cara ini, perubahan

kecil akan disetrika out. Kode terlihat sebagai berikut :

Line 1 const unsigned int X_AXIS_PIN = 2;

- const unsigned int Y_AXIS_PIN = 1;

- const unsigned int Z_AXIS_PIN = 0;

- const unsigned int NUM_AXES = 3;

5 const unsigned int PINS[NUM_AXES] ={

- X_AXIS_PIN, Y_AXIS_PIN, Z_AXIS_PIN

- };

- const unsigned int BUFFER_SIZE = 16;


10

- int buffer[NUM_AXES][BUFFER_SIZE];

- int buffer_pos[NUM_AXES] = { 0 }

-

- void setup(){

15 Serial.begin(BAUD_RATE);

- }

-

- int get_axis(const int axis){

- delay(1);

20 buffer[axis][buffer_pos[axis]] = analogRead(PINS[axis]);

- buffer_pos[axis] = (buffer_pos[axis] + 1) % BUFFER_SIZE;

-

- long sum = 0;

- for (int i = 0; i < BUFFER_SIZE; i++)

25 sum += buffer[axis][i];

- return round(sum / BUFFER_SIZE);

- }

-

- int get_x() { return get_axis(0);}

75

30 int get_y() { return get_axis(1);}

- int get_z() { return get_axis(2);}

-

- void loop(){

- Serial.print(get_x());

35 Serial.print(“");

- Serial.print(get_y());

- Serial.print(“");

- Serial.println(get_z());

- }

Seperti biasa, kita mendefinisikan beberapa konstanta untuk pin kita

gunakan pertama. Kali ini, kita juga mendefinisikan sebuah konstanta bernama

NUM_AXES yang berisi jumlah sumbu kita mengukur. Kita juga memiliki

sebuah array bernama PIN yang berisi daftar pin kita gunakan. Ini membantu kita

menjaga kode kita lebih generik nanti. Sejalan 11, kita menyatakan buffer untuk

semua sumbu. Mereka akan diisi dengan data sensor kita mengukur, sehingga kita

dapat menghitung nilai rata-rata ketika kita membutuhkannya. Kita harus

menyimpan posisi kita saat ini di setiap buffer, sehingga dalam baris 12, kita

mendefinisikan sebuah array dari posisi penyangga. setup () hanya

menginisialisasi port serial, dan tindakan nyata terjadi di yang get_axis ()

function.

Dimulai dengan penundaan kecil untuk memberikan Arduino beberapa

waktu untuk beralih antara pin analog, jika tidak, Anda mungkin mendapatkan

buruk data. Kemudian membaca percepatan untuk sumbu kita telah berlalu dan

menyimpannya di posisi buffer saat ini milik sumbu. Hal ini meningkatkan posisi

penyangga dan set kembali ke nol saat akhir buffer telah tercapai. Akhirnya, kita

kembali nilai rata-rata dari data yang kita telah dikumpulkan sejauh untuk sumbu

saat ini.

Itulah seluruh trik. Untuk melihat efeknya, meninggalkan sensor tersentuh

pada meja Anda, dan menjalankan program dengan ukuran buffer yang berbeda.

Jika Anda tidak menyentuh sensor, Anda tidak akan mengharapkan output

76

program untuk berubah. Tetapi jika Anda mengatur BUFFER_SIZE ke 1, Anda

dengan cepat akan melihat perubahan kecil. mereka akan menghilang segera

setelah buffer cukup besar. Data percepatan kita mengukur sekarang cukup akurat,

dan kita akhirnya dapat membangun sebuah game controller yang tidak akan

mengganggu pengguna karena gerakan tak terduga.

5.5 Kontroler dan Game

Pengendali Untuk membangun sebuah game controller full-blown, kita

hanya perlu menambahkan tombol untuk papan breadboard kita. (tolong,

doublecheck pin label di papan breakout Anda!).

Itulah bagaimana tampilannya di dalam game controller khas modern. Kita

akan tidak membangun perumahan mewah untuk controller, tapi kita masih harus

berpikir tentang ergonomi sejenak. Solusi papan breadboard kita saat ini adalah

agak rapuh, dan Anda tidak bisa benar-benar gelombang di sekitar papan ketika

itu terhubung ke Arduino.

Cepat atau lambat Anda akan melepas beberapa kabel, dan kontroler akan

berhenti bekerja. Untuk mengatasi masalah ini, Anda bisa mencoba untuk

melampirkan papan breadboard dengan Arduino menggunakan beberapa karet

gelang. Yang bekerja, tetapi tidak terlihat sangat cantik, dan itu masih sulit untuk

menangani.

Sebuah solusi yang jauh lebih baik adalah dengan menggunakan perisai

Arduino Prototyping. Ini adalah papan breadboard pluggable yang memungkinkan

Anda dengan cepat membangun sirkuit prototipe. Papan breadboard ini dikelilingi

oleh pin Arduino itu, sehingga Anda tidak perlu lagi kabel panjang. Shields adalah

cara yang bagus untuk meningkatkan kemampuan Arduino, dan Anda bisa

mendapatkan perisai bagi banyak berbeda tujuan seperti menambahkan Ethernet,

suara, display, dan seterusnya.

77

Sekarang bahwa hardware selesai, kita perlu versi akhir pertandingan

software pengendali. Ini mendukung tombol kita telah menambahkan, dan

melakukan anti-jittering yang telah kita buat, Mencari dan Poles Ujung Val UES,

di halaman 137:

#include <Bounce.h>





const unsigned int NUM_AXES = 3;

const unsigned int PINS[NUM_AXES] ={

X_AXIS_PIN, Y_AXIS_PIN, Z_AXIS_PIN

};

const unsigned int BUFFER_SIZE = 16;


int buffer[NUM_AXES][BUFFER_SIZE];

int buffer_pos[NUM_AXES] = { 0 };

Bounce button(BUTTON_PIN, 20);

void setup() {



}

int get_axis(const int axis) {

delay(1);

buffer[axis][buffer_pos[axis]] = analogRead(PINS[axis]);

buffer_pos[axis] = (buffer_pos[axis] + 1) % BUFFER_SIZE;

long sum = 0;

for (int i = 0; i < BUFFER_SIZE; i++)

sum += buffer[axis][i];

return round(sum / BUFFER_SIZE);

}

78

int get_x() { return get_axis(0); }

int get_y() { return get_axis(1); }

int get_z() { return get_axis(2);}

void loop() {

Serial.print(get_x());

Serial.print(“");

Serial.print(get_y());

Serial.print(“");

Serial.print(get_z());

Serial.print(“");

if (button.update())

Serial.println(button.read() == HIGH ?”1”:”0");

else

Serial.println("0");

}

Kita menggunakan Bouncing Class untuk menghilangkan bounce tombol.

Sisanya kode ini cukup banyak standar, dan satu-satunya hal yang layak disebut

adalah bahwa kita menggunakan 19200 baud tingkat untuk mentransfer data

pengontrol cukup cepat. Kompilasi dan meng-upload kode, buka terminal serial,

dan bermain-main dengan controller. Pindahkan, tekan tombol kadang-kadang,

dan seharusnya output sesuatu seperti berikut:

324 365 396 0

325 364 397 0

325 364 397 1

325 364 397 0

325 365 397 0

325 365 397 1

326 364 3970

79

Sebuah game controller buatan sendiri bagus, tapi apakah tidak akan

bahkan lebih baik jika kita juga memiliki permainan yang mendukungnya? Itulah

apa yang akan kita membangun di akhir bab.

5.6 Membuat Game Sendiri

Untuk menguji pengendali permainan kita, kita akan memprogram

Breakout3 clone sederhana di Processing. Tujuan permainan ini adalah untuk

menghancurkan semua batu bata di bagian atas dari layar dengan bola. Anda dapat

mengontrol bola dengan dayung di bawah layar, dan Anda dapat memiringkan

controller di sekitar sumbu x untuk memindah pemukul horizontal.

Meskipun ini bukan buku tentang pemrograman game, tidak akan sakit

untuk melihat jeroan permainan, terutama karena pemrograman game Pengolahan

dengan benar-benar menyenangkan murni! Ambil kode dari website4 buku dan

main game sebelum Anda menyelam ke dalam kode. Karena kita akan

menghubungkan game controller kita ke port serial, kita memiliki untuk

menginisialisasi:

import processing.serial.*;

Serial arduinoPort;

Kemudian kita mendefinisikan beberapa konstanta yang akan membantu kita

untuk menyesuaikan permainan mudah:

final int COLUMNS = 7;

final int ROWS = 4;

final int BALL_RADIUS = 8;

final int BALL_DIAMETER = BALL_RADIUS * 2;

final int MAX_VELOCITY = 8;

final int PADDLE_WIDTH = 60;

final int PADDLE_HEIGHT = 15;

80

final int BRICK_WIDTH = 40;

final int BRICK_HEIGHT = 20;

final int MARGIN = 10;

final int WIDTH = COLUMNS * BRICK_WIDTH + 2 * MARGIN;

final int HEIGHT = 300;

final int X_AXIS_MIN = 252;

final int X_AXIS_MAX = 443;

final int LINE_FEED = 10;

final int BAUD_RATE = 19200;

Sebagian besar nilai-nilai ini harus cukup jelas-mereka menentukan

ukuran dari obyek yang muncul di layar. Sebagai contoh, PADDLE_ WI DT H

adalah lebar dayung diukur dalam pixel, dan KOLOM dan ROWS mengatur tata

letak batu bata. Anda harus mengganti X_AXIS_MIN dan X_AXIS_MAX untuk

mengukur nilai-nilai minimum dan maksimum Anda untuk sensor Anda.

Selanjutnya kita memilih cara untuk mewakili objek permainan :

int px, py;

int vx, vy;

int xpos = WIDTH / 2;

int[][] bricks = new int[COLUMNS][ROWS];

Kita menyimpan x saat bola 'dan y koordinat di px dan py. untuk yang x saat ini

dan kecepatan y, kita menggunakan vx dan vy. Kita menyimpan dayung itu x

posisi dalam xpos. batu bata adalah array dua dimensi dan berisi keadaan saat ini

batu bata di layar. Jika elemen array diatur ke 1, yang sesuai bata masih di layar. 0

berarti bahwa telah hancur sudah. Akhirnya, kita perlu menyimpan kemungkinan

kondisi permainan:

boolean buttonPressed = false;

boolean paused = true;

81

boolean done = true;

Tidak mengherankan, kita menetapkan buttonPressed untuk benar ketika tombol

pada controller ditekan. Jika tidak, itu adalah fal se. dijeda memberitahu Anda

apakah permainan saat ini dihentikan sementara, dan dilakukan adalah benar

ketika tingkat saat ini dilakukan, yaitu, ketika semua batu bata telah hancur.

Setiap program Pengolahan membutuhkan setup () fungsi, dan di sini adalah milik

kita:

void setup() {

size(WIDTH, HEIGHT);

noCursor();

textFont(loadFont("Verdana-Bold-36.vlw"));

initGame();

println(Serial.list());

arduinoPort = new Serial(this, Serial.list()[0], BAUD_RATE);

arduinoPort.bufferUntil(LINE_FEED);

}

void initGame() {

initBricks();

initBall();

}

void initBricks() {

for (int x = 0; x < COLUMNS; x++)

for (int y = 0; y < ROWS; y++)

bricks[x][y] = 1;

}

void initBall() {

px = width / 2;

py = height / 2;

vx = int(random(-MAX_VELOCITY, MAX_VELOCITY));

vy = -2;

82

}

Setup () fungsi menginisialisasi layar, menyembunyikan pointer mouse dengan

noCursor (), dan menyetel font yang akan kita gunakan untuk pesan keluaran

(membuat font menggunakan Alat Pengolahan s> Buat menu Font). Kemudian

kita sebut initGame () untuk menginisialisasi batu bata array dan posisi bola saat

ini dan kecepatan. Untuk membuat hal-hal lebih menarik, kecepatan dalam arah x

diatur ke nilai acak. Kita mengatur kecepatan untuk arah y ke -2, yang membuat

bola jatuh pada kecepatan yang wajar. Sekarang semuanya sudah diinisialisasi,

kita dapat mengimplementasikan utama permainan lingkaran. Metode pengolahan

imbang () adalah tempat yang sempurna:

void draw() {

background(0);

stroke(255);

strokeWeight(3);

done = drawBricks();

if (done){

paused = true;

printWinMessage();

}

if (paused)

printPauseMessage();

else

updateGame();

drawBall();

drawPaddle();

}

Kita menghapus layar dan cat itu hitam dengan menggunakan latar belakang ().

Kemudian kita mengatur warna stroke putih dan berat stroke tiga piksel. setelah

bahwa kita menarik batu bata yang tersisa. Jika tidak ada batu bata yang tersisa,

83

kita menghentikan sementara permainan dan mencetak”Anda Menang!”pesan.

Jika permainan dihentikan sementara, kita mencetak pesan yang sesuai, dan jika

tidak, kita memperbarui kondisi permainan saat ini. Akhirnya, kita menarik bola

dan mendayung di posisi mereka saat menggunakan fungsi-fungsi berikut:

boolean drawBricks() {

boolean allEmpty = true;

for (int x = 0; x < COLUMNS; x++){

for (int y = 0; y < ROWS; y++) {

if (bricks[x][y] > 0){

allEmpty = false;

fill(0, 0, 100 + y * 8);

rect(

MARGIN + x * BRICK_WIDTH,

MARGIN + y * BRICK_HEIGHT,

BRICK_WIDTH,

BRICK_HEIGHT

);

}

}

}

return allEmpty;

}

void drawBall() {

strokeWeight(1);

fill(128, 0, 0);

ellipse(px, py, BALL_DIAMETER, BALL_DIAMETER);

}

void drawPaddle() {

int x = xpos - PADDLE_WIDTH / 2;

int y = height - (PADDLE_HEIGHT + MARGIN);

strokeWeight(1);

84

fill(128);

rect(x, y, PADDLE_WIDTH, PADDLE_HEIGHT);

}

Seperti yang Anda lihat, bola tidak lain adalah lingkaran, dan batu bata dan

dayung adalah persegi panjang sederhana. Untuk membuat mereka terlihat lebih

menarik, kita memberi mereka perbatasan bagus. Mencetak pesan permainan

mudah, juga:

void printWinMessage() {

fill(255);

textSize(36);

textAlign(CENTER);

text("YOU WIN!", width / 2, height * 2 / 3);

}

void printPauseMessage() {

fill(128);

textSize(16);

textAlign(CENTER);

text("Press Button to Continue", width / 2, height * 5 / 6);

}

Update () fungsi sangat penting, karena itu update permainan collision-check,

bergerak bola, dan sebagainya:

void updateGame() {

if (ballDropped()){

initBall();

paused = true;

} else {

checkBrickCollision();

checkWallCollision();

85

checkPaddleCollision();

px += vx;

py += vy;

}

}

Ketika pemain tidak memukul bola dengan dayung dan tetes keluar dari playfield,

permainan berhenti, dan pengguna diijinkan untuk melanjutkan setelah menekan

tombol. Dalam pertandingan final, Anda akan menurunkan beberapa jenis

kehidupan counter dan cetak”Game Over”pesan ketika counter mencapai nol. Jika

bola masih dalam bermain, kita memeriksa untuk berbagai tabrakan. Kita

memeriksa apakah bola telah mencapai satu atau lebih batu bata, jika telah

menabrak dinding, atau jika telah memukul dayung. Kemudian kita menghitung

posisi baru bola. Pemeriksaan tabrakan terlihat rumit, tetapi mereka cukup

sederhana dan hanya membandingkan bola berkoordinasi dengan koordinat semua

benda lain pada layar:

boolean ballDropped() {

return py + vy > height - BALL_RADIUS;

}

boolean inXRange(final int row, final int v) {

return px + v > row * BRICK_WIDTH &&

px + v < (row + 1) * BRICK_WIDTH + BALL_DIAMETER;

}

boolean inYRange(final int col, final int v) {

return py + v > col * BRICK_HEIGHT &&

py + v < (col + 1) * BRICK_HEIGHT + BALL_DIAMETER;

}

void checkBrickCollision() {

for (int x = 0; x < COLUMNS; x++){

for (int y = 0; y < ROWS; y++) {

if (bricks[x][y] > 0){

86

if (inXRange(x, vx) && inYRange(y, vy)) {

bricks[x][y] = 0;

if (inXRange(x, 0)) // Hit top or bottom of brick.

vy = -vy;

if (inYRange(y, 0)) // Hit left or right side of brick.

vx = -vx;

}

}

}

}

}

void checkWallCollision() {

if (px + vx < BALL_RADIUS || px + vx > width - BALL_RADIUS)

vx = -vx;

if (py + vy < BALL_RADIUS || py + vy > height - BALL_RADIUS)

vy = -vy;

}

void checkPaddleCollision() {

final int cx = xpos;

if (py + vy >= height - (PADDLE_HEIGHT + MARGIN + 6) &&

px >= cx - PADDLE_WIDTH / 2 &&

px <= cx + PADDLE_WIDTH / 2)

{

vy = -vy;

vx = int(

map(

px - cx,

-(PADDLE_WIDTH / 2), PADDLE_WIDTH / 2,

-MAX_VELOCITY,

MAX_VELOCITY

)

);

87

}

}

Perhatikan bahwa collision-check juga mengubah kecepatan dari bola jika

diperlukan. Sekarang bola bergerak, itu akan adil untuk memindah pemukul, juga.

Seperti dikatakan sebelumnya, Anda mengendalikan dayung dengan memiringkan

kontroler game sekitar sumbu x. Berikut kode yang mendapat data pengontrol

melalui port serial:

Line 1 void serialEvent(Serial port) {

- final String arduinoData = port.readStringUntil(LINE_FEED);

-

- if (arduinoData!= null){

5 final int[] data = int(split(trim(arduinoData), ' '));

- if (data.length == 4){

- buttonPressed = (data[3] == 1);

- if (buttonPressed){

- paused =!paused;

10 if (done){

- done = false;

- initGame();

- }

- }

15

- if (!paused)

- xpos = int(map(data[0], X_AXIS_MIN, X_AXIS_MAX, 0, WIDTH));

- }

- }

20 }

Pengolahan panggilan serialEvent () fungsi setiap kali data baru tersedia

pada port serial. Controller mengirimkan data baris demi baris nya. masing-

88

masing baris berisi percepatan saat ini x -, y -, dan z - sumbu dan keadaan saat

tombol. Ini memisahkan semua atribut dengan kosong. Jadi, dalam serialEvent (),

kita membaca baris baru, split pada karakter kosong, dan mengkonversi string

dihasilkan menjadi nilai int. Ini semua terjadi di baris 5. Kita memeriksa apakah

kita benar-benar mendapat semua empat atribut, dan kemudian kita melihat

apakah pemain telah menekan tombol pada kontroler game. jika ya, kita beralih

keadaan jeda : jika permainan saat berada dalam mode jeda, kita melanjutkan

permainan, jika tidak, kita pause.

Kita juga harus memeriksa apakah permainan telah selesai. Jika ya, kita

memulai permainan baru. Akhirnya, kita membaca X akselerasi saat ini di baris

17 dan peta itu ke posisi x kemungkinan dayung kita. Itu benar-benar semua yang

harus kita lakukan untuk memindah pemukul menggunakan game controller kita

sendiri. Juga, tidak masalah jika Anda menggunakan controller untuk mengontrol

permainan atau jenis yang sama sekali berbeda perangkat lunak. Anda hanya perlu

membaca empat nilai integer dari serial pelabuhan ketika Anda membutuhkannya.

Pada bagian ini, Anda telah belajar lebih banyak tentang pemrograman

game daripada tentang pemrograman Arduino atau perangkat keras. Tapi Anda

harusnya telah belajar bahwa sangat mudah untuk mengintegrasikan elektronik

yang dirancang dengan baik proyek ke proyek perangkat lunak biasa. Kita dengan

hati-hati menganalisis data analog dikembalikan oleh accelerometer, dan

kemudian kita menghapus semua jitter yang tidak diinginkan. Ini adalah teknik

yang akan Anda gunakan sering dalam elektronik Anda proyek, dan kita akan

menggunakannya lagi di bab berikutnya.

6.7 Aplikasi Proyek

Jika Anda menjaga mata Anda terbuka, Anda akan segera menemukan

lebih banyak aplikasi untuk accelerometers daripada yang Anda bayangkan.

Berikut adalah koleksi kecil baik komersial dan gratis produk :

• Nike iPod Sport Kit mendukung Anda dalam latihan sehari-hari Anda, dan itu

didasarkan pada accelerometer, juga.

89

• Ini sangat menyenangkan untuk membuat marmer labirin permainan komputer

dan kontrol menggunakan kontroler game kita membangun dalam bab ini.

• Dalam bab ini, kita telah diukur hanya percepatan langsung; bahwa adalah, kita

biasanya memiliki accelerometer di tangan kita dan memindahkannya.


Kita memiliki beberapa item khusus seperti protoshield tersebut. Pastikan

bahwa itu duduk dengan benar di atas Arduino dan bahwa tidak satupun dari

konektor yang sengaja menyelinap masa lalu socket. Kadang-kadang header

keluar dari bentuk, sehingga mungkin terjadi. Periksa apakah Anda telah disolder

header pin dengan benar untuk breakout papan.

Gunakan kaca pembesar dan mempelajari setiap solder sendi tunggal

dengan hati-hati. Apakah Anda cukup menggunakan solder? Apakah Anda

menggunakan terlalu banyak dan menghubungkan dua sendi?

6.9 Latihan

• Buat mouse komputer Anda sendiri dengan menggunakan accelerometer

ADXL335. Ini harus bekerja di udara bebas, dan harus memancarkan arus

percepatan sekitar x-dan y-sumbu. Hal ini juga harus memiliki kiri tombol dan

tombol kanan. Menulis beberapa kode Processing (atau mungkin kode dalam

bahasa pemrograman pilihan Anda?) untuk mengontrol pointer mouse pada layar.

90

Jaringan Arduino

Dengan Arduino standalone, Anda dapat membuat proyek-proyek yang

tak terhitung jumlahnya menyenangkan dan berguna. Tapi segera setelah Anda

mengubah Arduino menjadi perangkat jaringan, Anda membuka berbagai

kemungkinan baru. Anda sekarang memiliki akses ke semua informasi di internet,

sehingga Anda bisa mengubah Arduino Anda menjadi stasiun cuaca hanya dengan

membaca data dari layanan cuaca. Anda juga dapat mengubah Arduino menjadi

web server yang menyediakan data sensor untuk perangkat lain atau komputer

pada Anda di web.

Dalam proyek akan membangun sebuah alarm pencuri email dalam bab

ini. mendeteksi gerak dalam ruang tamu Anda, dan Arduino akan mengirimkan

email ketika mendeteksi gerakan selama ketidakhadiran Anda. Karena ini adalah

proyek agak maju, pertama-tama kita akan bekerja pada beberapa proyek-proyek

kecil untuk mempelajari semua teknik dan keterampilan yang diperlukan.

Kita akan mulai dengan”telanjang”Arduino yang tidak memiliki kemampuan

jaringan.

Anda masih dapat melampirkan ke Internet, asalkan Anda

menghubungkannya ke PC. Untuk proyek kedua kita, kita akan memperbaiki

situasi dramatis dengan perisai Ethernet. Sekarang Arduino Anda menjadi

jaringan full-blown perangkat yang langsung dapat mengakses layanan IP seperti

layanan SIANG.

Ini akan mengubah Arduino Anda menjadi jam yang sangat akurat.

Setelah kita dapat untuk mengakses layanan IP, maka kita akan belajar bagaimana

untuk mengirim email langsung dari Arduino dengan perisai Ethernet. Untuk

alarm pencuri, kita kemudian hanya perlu tahu bagaimana untuk mendeteksi

gerakan. Dalam hal ini, kita akan menggunakan sensor inframerah pasif ( PIR ).

91


1. Sebuah perisai Ethernet untuk Arduino

2. Sebuah sensor suhu TMP36

3. A PIR sensor gerak inframerah

4. Sebuah papan breadboard

5. beberapa kabel



6.2 PC Transfer Sensor data ke Internet

Semuanya dimulai dengan 38.400 modem baud, Netscape Navigator 3,

dan salah satu disket AOL atau CD - ROM Anda punya di mail. Hari ini Anda

mungkin memiliki akses broadband melalui kabel, satelit, atau DSL, dan itu

mungkin tersedia di mana-mana di rumah Anda melalui WiFi. Jadi, kita akan

mulai dengan menggunakan koneksi yang ada untuk menghubungkan Anda

Arduino ke Internet.

Sebuah program berjalan pada PC Anda dan berkomunikasi dengan

Arduino menggunakan port serial. Setiap kali aplikasi membutuhkan Internet

akses, program pada PC berhubungan dengan itu. Menggunakan arsitektur ini,

Anda dapat tweet1 data sensor yang menarik. Kita akan membangun sebuah

sistem yang tweet pesan segera karena suhu di ruang kerja atau kantor melebihi

batas tertentu, yaitu, 32 derajat Celsius (90 derajat Fahrenheit). Cobalah

mengupload sketsa berikut untuk Arduino Anda :

Line 1 #define CELSIUS

-

- const unsigned int TEMP_SENSOR_PIN = 0;


5 const float SUPPLY_VOLTAGE = 5.0;

92

-

- void setup(){


- }

10

- void loop(){

- const int sensor_voltage = analogRead(TEMP_SENSOR_PIN);

- const float voltage = sensor_voltage * SUPPLY_VOLTAGE / 1024;

- const float celsius = (voltage * 1000 - 500) / 10;

15 #ifdef CELSIUS

- Serial.print(celsius);

- Serial.println(“C");

- #else

- Serial.print(9.0 / 5.0 * celsius + 32.0);

20 Serial.println(“F");

- #endif

- delay(5000);

- }

Ini hampir sketsa yang sama kita telah digunakan sebelumnya. Perlu

diingat bahwa Anda harus menetapkan SUPPLY_VOLTAGE menjadi 3,3 di baris

5, jika Anda menggunakan Arduino yang berjalan dengan 3.3V bukan 5V.

Kita mendukung baik Celcius dan Fahrenheit nilai sekarang, dan Anda dapat

mengontrol Unit yang harus digunakan dengan konstanta preprocessor. Jika Anda

mengatur yang CELSIUS konstan dalam baris pertama, aplikasi output suhu

dalam derajat Celcius.

Jika Anda menghapus baris pertama atau mengubahnya menjadi baris

komentar, Fahrenheit akan digunakan. Untuk mengubah perilaku aplikasi, kita

menggunakan preprocessor # ifdef direktif. Ia memeriksa apakah preprocessor

konstan tertentu telah mengatur, dan kemudian mengkompilasi kode kondisional.

Dalam kasus kita, itu akan mengkompilasi Celcius - to- Fahrenheit rumus di baris

93

19 hanya jika CELSIUS konstan belum ditetapkan. Upload sketsa, dan itu akan

menampilkan suhu saat ini ke port serial setiap lima detik. Outputnya terlihat

sebagai berikut :

27.15C

26.66C

27.15C

Yang kita butuhkan sekarang adalah sebuah program yang berjalan pada

PC Anda yang membaca ini output dan tweet pesan segera karena suhu lebih

besar dari 32 derajat Celcius ( 90 derajat Fahrenheit ). Kita bisa menggunakan

bahasa pemrograman yang mampu membaca dari port serial dan yang mendukung

Twitter, tetapi karena kita telah menggunakan Processing dalam semua lainnya

contoh, kita akan menggunakannya untuk proyek ini juga.

6.3 Mendaftarkan Aplikasi di Twitter

Sebelum kita mulai coding, kita harus mendaftarkan aplikasi kita di twitter

website untuk mendapatkan akses OAuth token.2 OAuth adalah otentikasi skema

yang memungkinkan aplikasi untuk menggunakan sumber daya aplikasi lain '.

Dalam kasus kita, kita akan memberikan aplikasi kita sendiri hak untuk

memperbarui kita Twitter feed tanpa menggunakan username dan password

Twitter kita. Untuk waktu yang lama, Twitter didukung HTTP Basic

authentication. Layanan otomatis hanya membutuhkan username dan password

untuk meminta atau memperbarui Twitter feed. Tapi seperti Agustus 2010,

Twitter telah menghapus dukungan untuk otentikasi dasar dan sekarang

menggunakan OAuth.

Untuk mendapatkan token akses OAuth, daftar aplikasi baru di

Bagian pengembang website.4 Twitter Setelah Anda login, klik”Daftar

aplikasi”link, dan mengisi formulir yang Anda lihat pada, pada halaman

94

berikutnya. Pastikan Anda mengatur jenis aplikasi untuk Client dan tipe akses

standar Membaca & Menulis. Anda dapat mengatur aplikasi nama ke string yang

sewenang-wenang, dan akan muncul pada saluran Twitter Anda setiap kali Anda

menggunakan aplikasi untuk tweet pesan. Jika Anda menetapkan untuk

RescueMeFromWork, misalnya, tweet Anda akan dipublikasikan melalui

RescueMeFromWork.

Setelah Anda telah terdaftar aplikasi baru Anda berhasil, pergi ke

halaman pengaturan aplikasi untuk melihat kunci konsumen dan konsumen

rahasia. Anda perlu mereka bersama-sama dengan tanda OAuth dan OAuth Anda

tanda rahasia untuk memungkinkan Anda aplikasi mengubah status Twitter Anda.

Untuk melihat tanda OAuth dan rahasia, ikuti link My Access Token.

Salin kunci konsumen, rahasia konsumen, token akses, dan akses rahasia tanda.

Anda akan membutuhkan mereka di bagian berikutnya ketika kita menciak pesan

menggunakan Processing.

6.4 Tweeting Pesan dengan Processing

Pengolahan tidak memiliki dukungan Twitter, tetapi dalam program

Processing, kita memiliki akses langsung ke library Jawa, dan Anda dapat

menemukan beberapa yang baik Library Twitter for Java. Salah satunya adalah

twitter4j.5 Kita akan menggunakannya karena itu sangat matang dan memiliki

dukungan yang sangat baik OAuth.

Download dari situsnya, 6 dan mengekstrak ke folder sementara.

Tergantung pada versi Anda men-download, Anda akan menemukan sebuah file

bernama twitter4j-core-xyzjar atau twitter4j-core-xyz-SNAPSHOT.jar dalam

folder. Buka Processing IDE, membuat sketsa baru, dan kemudian drag dan drop

jar. untuk IDE (file jar. secara otomatis akan disalin ke lokal

folder bernama code). Itulah yang harus Anda lakukan untuk memberikan aplikasi

Anda akses ke library twitter4j.

95

Kita melanjutkan dengan beberapa kode boilerplate:

import processing.serial.*;

final float MAX_WORKING_TEMP = 32.0;

final int LINE_FEED = 10;

final int BAUD_RATE = 9600;

final String CONSUMER_KEY =“<YOUR CONSUMER KEY>";

final String CONSUMER_SECRET =“<YOUR CONSUMER SECRET>";

final String ACCESS_TOKEN =“<YOUR ACCESS TOKEN>";

final String ACCESS_TOKEN_SECRET =“<YOUR ACCESS TOKEN

SECRET>";

Serial arduinoPort;

void setup() {

println(Serial.list());

arduinoPort = new Serial(this, Serial.list()[0], BAUD_RATE);

arduinoPort.bufferUntil(LINE_FEED);

}

void draw() {}

Seperti biasa, kita mengimpor library serial untuk berkomunikasi dengan

Arduino, dan kemudian kita mendefinisikan beberapa konstanta kita butuhkan

nanti. sebagian besar mereka mengandung kepercayaan yang kita butuhkan untuk

mengakses layanan Twitter. dengan MAX_WORKING_TEMP, Anda dapat

menentukan di mana suhu aplikasi mulai tweet. Ini bisa menjadi derajat Celcius

atau Fahrenheit nilai.

Dalam metode setup (), kita mencetak daftar semua perangkat serial yang

tersedia, dan kita menginisialisasi variabel SerialPort kita dengan hotel pertama

yang kita temukan, berharap bahwa itu adalah Arduino. Anda bisa loop melalui

daftar secara otomatis dan mencari sesuatu yang terlihat seperti nama port

Arduino, tapi itu akan menjadi rapuh, juga. Kita tidak memerlukan output grafis

96

untuk aplikasi kita, sehingga metode draw () masih kosong. Sekarang mari kita

menerapkan logika bisnis yang sebenarnya dari kita”Bawa saya ke beach”alarm :

void serialEvent(Serial port) {

final String arduinoData = port.readStringUntil(LINE_FEED);

if (arduinoData!= null) {

final String[] data = split(trim(arduinoData), ' ');

if (data.length == 2 &&

(data[1].equals("C") || data[1].equals("F")))

{

float temperature = float(data[0]);

println(temperature);

int sleepTime = 5 * 60 * 1000;

if (temperature > MAX_WORKING_TEMP) {

tweetAlarm();

sleepTime = 120 * 60 * 1000;

}

try{

Thread.sleep(sleepTime);

}

catch(InterruptedException ignoreMe) {}

}

}

}

void tweetAlarm(){

TwitterFactory factory = new TwitterFactory();

Twitter twitter = factory.getInstance();

twitter.setOAuthConsumer(CONSUMER_KEY, CONSUMER_SECRET);

AccessToken accessToken = new AccessToken(

ACCESS_TOKEN,

ACCESS_TOKEN_SECRET

);

97

twitter.setOAuthAccessToken(accessToken);

try{

Status status = twitter.updateStatus(

"Someone, please, take me to the beach!"

);

println(

"Successfully updated status to '“+ status.getText() +”'."

);

}

catch (TwitterException e){

e.printStackTrace();

}

}

Pelaksana Serial Komunikasi di Processing, pada halaman 126, Anda

belajar bagaimana menerapkan komunikasi serial di Processing. Setiap kali data

baru tiba di port serial, lingkungan runtime memanggil serialEvent () method. Di

sana kita mencoba untuk membaca satu baris teks, dan kemudian kita cek apakah

mengandung angka desimal yang diikuti oleh kosong dan C atau F karakter. Hal

ini membuat yakin kita sudah membaca aktual mengatur data suhu dan bukan

sampah digital.

Jika kita punya satu set data temperatur sintaksis benar, kita mengubahnya

menjadi benda mengambang dan cek untuk melihat apakah itu lebih besar dari

MAX_WORKING_TEMP (tidak ada yang harus dipaksa untuk bekerja pada suhu

yang tinggi!). Jika ya, kita panggilan tweetAlarm () dan tweet pesan untuk

mendorong beberapa pengikut untuk menyelamatkan kita. Kemudian kita

menunggu selama dua jam sampai kita cek berikutnya. Jika tidak,

kita menunggu lima menit dan memeriksa suhu lagi. TweetAlarm ( ) update

channel Twitter dan sederhana.

Dalam Java, kita membuat Twitter contoh baru menggunakan Twitter dan

mengatur kredensial konsumen kita dengan memanggil setOAuthConsumer ( ).

98

Kemudian kita mengatur kredensial OAuth memanggil setOAuthAccessToken ( ).

Akhirnya, kita memanggil UpdateStatus ( ). Jika semuanya berjalan dengan baik,

kita mencetak pesan sukses ke konsol. Jika ada yang tidak beres, UpdateStatus ( )

akan memunculkan pengecualian, dan kita mencetak nya jejak stack untuk

keperluan debugging. Itu semua kode yang kita butuhkan, sehingga

menghubungkan Arduino ke PC dan menjalankannya.

Menggunakan PC full-blown sebagai relay Internet untuk Arduino Anda

nyaman, tetapi juga berlebihan untuk sebagian besar aplikasi. Pada bagian

berikutnya, Anda akan belajar bagaimana mengubah sebuah Arduino menjadi

sebuah perangkat jaringan yang nyata.

6.5 Berkomunikasi Menggunakan Perisai Ethernet

Pada bagian sebelumnya, Anda belajar bagaimana untuk membangun

aplikasi jaringan dengan Arduino dengan menggunakan koneksi jaringan PC

Anda. pendekatan ini bekerja dengan baik, tetapi juga memiliki beberapa

kelemahan. Masalah terbesar adalah bahwa Anda memerlukan PC yang lengkap,

sedangkan untuk banyak aplikasi Arduino yang kemampuan hardware akan

cukup. Pada bagian ini, Anda akan belajar bagaimana memecahkan masalah ini

dengan perisai Ethernet. Anda tidak dapat menghubungkan Arduino telanjang ke

jaringan. Tidak hanya perangkat keras kemampuan terlalu terbatas, juga tidak

memiliki port Ethernet. Itu berarti Anda tidak bisa pasang kabel Ethernet ke

dalamnya, dan untuk mengatasi hal ini pembatasan, Anda harus menggunakan

perisai Ethernet.

Perisai tersebut datang dengan chip Ethernet dan konektor Ethernet dan

mengubah Anda menjadi Arduino perangkat jaringan segera. Anda hanya perlu

pasang masuk Anda dapat memilih dari beberapa produk, mereka semua baik dan

melayani mereka Tujuan well.7 Untuk prototyping saya lebih”resmi”perisai, 8

karena dilengkapi dengan soket untuk semua pin. Juga pada saat tulisan ini tim

99

Arduino mengumumkan

Arduino Ethernet, sebuah papan Arduino yang dilengkapi dengan Ethernet

pelabuhan dan tidak membutuhkan perisai yang terpisah. Hardware hanyalah

salah satu aspek untuk mengubah Arduino ke dalam jaringan perangkat. Kita juga

perlu beberapa perangkat lunak untuk komunikasi jaringan.

Arduino IDE dilengkapi dengan library Ethernet nyaman yang berisi

beberapa kelas yang berhubungan dengan jaringan. Kita akan menggunakannya

sekarang untuk mengakses sebuah DAYTIME

layanan di Internet. Sebuah service9 DAYTIME mengembalikan tanggal dan

waktu sebagai ASCII String. Server DAYTIME mendengarkan pada baik TCP

atau port UDP 13. anda dapat menemukan banyak layanan SIANG di Internet,

salah satunya berjalan di time.nist.gov. Sebelum kita menggunakan layanan

pemrograman dengan Arduino, melihat cara kerjanya menggunakan perintah

telnet:

Trying 192.43.244.18...

Connected to time.nist.gov.

Escape character is '^]'.

55480 10-10-11 13:25:35 28 0 0 138.5 UTC(NIST)*

Connection closed by foreign host.

Segera setelah perintah telnet terhubung ke server DAYTIME, itu

mengirimkan kembali waktu saat ini dan date.10 Kemudian layanan menutup

koneksi langsung.

Berikut ini adalah implementasi dari perilaku yang sama persis untuk Arduino

dengan perisai Ethernet:

Line 1 #include <SPI.h>

- #include <Ethernet.h>

-

- const unsigned int DAYTIME_PORT = 13;

5 const unsigned int BAUD_RATE = 9600;

100

-

- byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

- byte my_ip[] = { 192, 168, 2, 120 };

- byte time_server[] = { 192, 43, 244, 18 }; // time.nist.gov

10

- Client client(time_server, DAYTIME_PORT);

-

- void setup(){

- Ethernet.begin(mac, my_ip);

15 Serial.begin(BAUD_RATE);

- }

-

- void loop(){

- delay(1000);

20 Serial.print("Connecting...");

-

- if (!client.connect()){

- Serial.println("connection failed.");

- } else{

25 Serial.println("connected.");

- delay(1000);

-

- while (client.available()){

- char c = client.read();

30 Serial.print(c);

- }

-

- Serial.println("Disconnecting.");

- client.stop();

35 }

- }

101

Pertama, kita termasuk library Ethernet dan menentukan konstan untuk

Port layanan DAYTIME ( kita juga harus menyertakan library SPI, karena library

Ethernet tergantung padanya ). Kemudian kita mendefinisikan tiga array byte :

• Mac berisi alamat MAC kita akan digunakan untuk Ethernet

perisai. Sebuah alamat MAC adalah nomor 48 - bit yang unik

mengidentifikasi device.11 jaringan Biasanya, produsen menetapkan ini

identifier, tapi untuk perisai Ethernet, kita harus mengatur diri kita sendiri ;

kita menggunakan nomor acak.

Catatan penting : alamat MAC harus unik pada jaringan Anda.

Jika Anda menghubungkan lebih dari satu Arduino, pastikan mereka semua

memiliki alamat MAC yang berbeda!

• Setiap kali Anda menghubungkan PC Anda ke Internet, mungkin akan

alamat IP baru melalui Dynamic Host Configuration Protocol

( DHCP ).12 Untuk sebagian besar aplikasi Arduino, implementasi DHCP

relatif mahal, sehingga Anda biasanya menetapkan alamat IP secara manual.

Dalam kebanyakan kasus, ini akan menjadi alamat lokal di 192.168.xy yang

Kisaran, kita menyimpan alamat ini dalam array my_ip.

• Untuk mengaktifkan nama domain seperti time.nist.gov ke alamat IP,

Anda memerlukan akses ke Domain Name System ( DNS ). The Arduino

library standar tidak mendukung DNS, jadi kita harus mengetahui

IP alamat diri kita sendiri. Kita menetapkan ke time_server. Perintah telnet

sudah berbalik layanan DAYTIME nama domain ke dalam

Alamat IP bagi kita. Atau, Anda dapat menggunakan salah satu dari berikut

perintah untuk menentukan alamat IP nama domain :

maik> host time.nist.gov

time.nist.gov has address 192.43.244.18

maik> dig +short time.nist.gov

192.43.244.18

102

maik> resolveip time.nist.gov

IP address of time.nist.gov is 192.43.244.18

maik> ping -c 1 time.nist.gov

PING time.nist.gov (192.43.244.18): 56 data bytes

64 bytes from 192.43.244.18: icmp_seq=0 ttl=48 time=173.598 ms

--- time.nist.gov ping statistics ---

1 packets transmitted, 1 packets received, 0.0% packet loss

round-trip min/avg/max/stddev = 173.598/173.598/173.598/0.000 ms

Di line 11, kita membuat objek Client baru. Kelas ini merupakan bagian

dari Ethernet library dan memungkinkan kita untuk membuat klien jaringan yang

terhubung ke alamat IP tertentu dan port. Sekarang kita harus menginisialisasi

Ethernet melindungi dirinya sendiri, kita melakukan ini sejalan 14 di setup ()

function. Kita harus memanggil Ethernet.begin (), MAC dan alamat IP. Kemudian

kita menginisialisasi port serial sehingga kita dapat output beberapa pesan debug.

Pada titik ini, kita telah diinisialisasi semua komponen yang kita butuhkan,

jadi kita akhirnya dapat terhubung ke server DAYTIME dan membaca output.

Harap dicatat bahwa Anda juga dapat melewati alamat IP dari gateway jaringan

Anda dan subnet mask untuk Ethernet.begin (). Hal ini diperlukan jika Anda

jangan menghubungkan Arduino langsung ke internet, namun menggunakan

router atau modem kabel sebagai gantinya. Dalam hal ini, Anda dapat melewati

alamat gateway sebagai berikut:

//...

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

byte my_ip[] = { 192, 168, 2, 120 };

byte time_server[] = { 192, 43, 244, 18 }; // time.nist.gov

// Insert IP address of your cable or DSL router below:

byte gateway[] = { 192, 168, 13, 254 };

Client client(time_server, DAYTIME_PORT);

void setup() {

Ethernet.begin(mac, my_ip, gateway);

103


}

//...

Loop () fungsi sketsa kita dimulai dengan penundaan singkat, yang

memungkinkan semua komponen untuk menginisialisasi benar. Hal ini diperlukan

karena Ethernet perisai adalah perangkat otonom yang mampu bekerja secara

paralel ke Arduino. Sejalan 22, kita mencoba untuk menyambung ke layanan

DAYTIME. jika koneksi tidak dapat dibangun, kita mencetak pesan kesalahan.

Jika tidak, kita tunggu setengah detik untuk memberikan layanan beberapa

persiapan waktu, dan kemudian kita membaca dan mencetak karakter output

dengan karakter.

Perhatikan bahwa antarmuka klien mirip dengan antarmuka Serial kelas.

Dengan tersedia (), kita dapat memeriksa apakah beberapa byte masih tersedia,

dan membaca () mengembalikan byte berikutnya. Pada akhirnya, kita sebut stop ()

untuk memutuskan sambungan dari layanan dan kemudian kita mulai lagi.

Menyusun dan meng-upload program ke Arduino. Kemudian buka serial

memantau, dan Anda akan melihat sesuatu seperti ini:

Connecting...connected.

55480 10-10-11 13:32:23 28 0 0 579.9 UTC(NIST) *

Disconnecting.

Connecting...connected.

55480 10-10-11 13:32:26 28 0 0 34.5 UTC(NIST) *

Disconnecting.

Selesai! Arduino kita langsung terhubung ke Internet, dan

bahkan melakukan sesuatu yang berguna: kita telah mengubahnya menjadi sebuah

jam yang sangat akurat. Semua dalam semua, jaringan dengan Arduino tidak

berbeda jauh dari jaringan dengan PC, jika Anda menggunakan perisai Ethernet.

Pada bagian berikutnya, Anda akan belajar bagaimana cara mengirim email

dengan Arduino.

104

6.6 Emailing dari Command Line

Sekarang kita tahu bagaimana untuk mengakses layanan jaringan, kita

akan terus membangun proyek lebih maju : sebuah alarm otomatis. jika seseorang

bergerak di ruang tamu kita, kita ingin mendapatkan email, jadi kita harus belajar

bagaimana untuk mengirim email dari Arduino. Meskipun email adalah layanan

penting, hanya sedikit orang yang tahu bagaimana benar-benar bekerja di

belakang layar. Untuk mengirim email dari Arduino, kita bisa memilih jalan yang

mudah dan menggunakan PC sebagai relay email.

Sebagai hacker sejati, kita akan mengikuti jalur yang lebih canggih dan

mengimplementasikan subset dari Simple Mail Transfer Protocol ( SMTP ).13

SMTP adalah protokol Internet yang khas. Ini hanya menggunakan teks, dan hal

ini terutama berbasis -line, yaitu, Anda bertukar informasi baris demi baris.

Tipikal email hanya terdiri dari beberapa atribut : pengirim, penerima, subjek, dan

badan pesan. Untuk mengirimkan email, Anda harus mengirim permintaan ke

server SMTP. Permintaan harus mematuhi spesifikasi SMTP.

Sebelum kita mengirim email menggunakan Arduino dan perisai Ethernet,

Anda harus belajar bagaimana untuk mengirim email dari baris perintah dengan

menggunakan perintah telnet. Untuk melakukannya, Anda harus mengetahui

alamat dari suatu SMTP server yang dapat Anda gunakan terlebih dahulu.

Petunjuk berikut mengasumsikan Anda menggunakan akun Google Mail

(http://gmail.com). Jika Anda menggunakan berbeda penyedia email, Anda harus

menyesuaikan nama domain sesuai. di kasus apapun, jangan penyalahgunaan

layanan mereka! Jika ragu, baca istilah penggunaannya!

Buka terminal, dan masukkan berikut ini:

105

maik> nslookup

> set type=mx

> gmail.com

Server: 192.168.2.1

Address: 192.168.2.1#53

Non-authoritative answer:

gmail.com mail exchanger = 5 gmail-smtp-in.l.google.com.

gmail.com mail exchanger = 10 alt1.gmail-smtp-in.l.google.com.

gmail.com mail exchanger = 20 alt2.gmail-smtp-in.

> exit

> exit

Perintah ini mengembalikan daftar semua pertukaran server Google Mail

(MX) yang tersedia pada jaringan Anda. Mengambil nama server pertama, dan

membuka

koneksi ke port standar SMTP 25 (ganti nama server

gmail-smtp-in.l.google.com dan semua alamat email yang sesuai):

( maik> telnet gmail-smtp-in.l.google.com 25

) Trying 74.125.77.27...

Connected to gmail-smtp-in.l.google.com.

Escape character is '^]'.

220 mx.google.com ESMTP q43si10820020eeh.100

( HELO

) 250 mx.google.com at your service

( MAIL FROM: <[email protected]>

) 250 2.1.0 OK q43si10820020eeh.100

( RCPT TO: <[email protected]>

) 250 2.1.5 OK q43si10820020eeh.100

( DATA

) 354 Go ahead q43si10820020eeh.100

( from: [email protected]

106

( to: [email protected]

( subject: This is a test

(

( Really, this is a test!

(.

) 250 2.0.0 OK 1286819789 q43si10820020eeh.100

( QUIT

) 221 2.0.0 closing connection q43si10820020eeh.100

Connection closed by foreign host.

Meskipun cara yang lebih kompleks, sesi ini mirip dengan SIANG kita

contoh. Kita hanya mengirim perintah yang lebih kompleks ( by the way, yang

Anda lakukan tidak perlu menulis perintah dalam huruf besar ). Pertama kita

mengirim HELLO perintah ( ejaan yang benar ) untuk membangun sebuah sesi

dengan SMTP Server. Kemudian kita memberitahu server bahwa kita ingin

mengirim email menggunakan MAIL FROM :

Alamat email yang kita sediakan dengan perintah ini akan digunakan oleh

server dalam kasus email kita memantul kembali. Perhatikan bahwa server

mengirimkan kembali baris respon untuk setiap permintaan. Respon ini selalu

mulai dengan tiga digit kode status.

RCPT TO : Perintah menetapkan alamat email penerima. Jika Anda ingin

untuk mengirim email ke lebih dari satu penerima, Anda harus mengulangi

perintah untuk masing-masing.

Dengan perintah DATA, kita memberitahu server yang sekarang kita

mulai untuk mengirimkan

atribut email itu. Atribut Email terutama daftar kunci / nilai pasangan mana kunci

dan nilai yang dipisahkan oleh titik dua. Jadi dalam tiga pertama garis, kita

mengatur atribut”dari”,”untuk”, dan”subjek,”dan mereka semua memiliki yang

berarti Anda harapkan ketika mengirim email.

Anda memisahkan tubuh email itu dari atribut menggunakan baris kosong

untuk menandai akhir dari badan email, mengirim baris yang berisi satu periode.

107

Mengirim perintah QUIT untuk mengakhiri sesi dengan server SMTP. Anda harus

menemukan sebuah email baru di kotak masuk Anda. Jika tidak, coba Server MX

lain pertama. Masih hal yang bisa salah, dan meskipun sederhana dalam teori,

SMTP bisa menjadi binatang yang kompleks dalam praktek.

Seringkali server SMTP kembali membantu pesan kesalahan yang dapat

membantu Anda untuk segera memecahkan masalah Anda. Jangan melanjutkan

sampai Anda telah berhasil dikirim email dari perintah line, karena merupakan

dasar untuk bagian berikutnya di mana Anda akan belajar

cara mengirim email dengan Arduino.

6.7 Emailing Langsung dari Arduino

Untuk mengirim email dari Arduino, kita pada dasarnya akan

melaksanakan sesi telnet dari bagian baris sebelumnya demi baris. Alih-alih hanya

Hardwiring atribut email ke dalam kode jaringan, kita akan membuat

desain yang lebih canggih.

Kita mulai dengan kelas Email:

#ifndef __EMAIL__H_

#define __EMAIL__H_

class Email {

String _from, _to, _subject, _body;

public:

Email(

const String& from,

const String& to,

const String& subject,

const String& body

) : _from(from), _to(to), _subject(subject), _body(body) {}

const String& getFrom() const { return _from; }

108

const String& getTo() const { return _to; }

const String& getSubject() const { return _subject; }

const String& getBody() const { return _body;}

};

#endif

Kelas ini merangkum empat atribut-email yang paling penting alamat

email dari pengirim dan penerima, subjek, dan badan pesan. Kita menyimpan

semua atribut sebagai obyek String. Tunggu sebentar... kelas String? Yes! Sejak

versi 19, Arduino IDE dilengkapi dengan string full-blown class.14 Ia tidak

memiliki banyak fitur sebagai C + + atau Java kelas string, tapi itu masih jauh

lebih baik daripada main-main dengan char pointer. Anda akan melihat bagaimana

menggunakannya dalam beberapa paragraf.

Sisanya kita kelas Email adalah cukup sederhana. Dalam konstruktor,

kita menginisialisasi semua variabel instan, dan kita memiliki metode untuk

mendapatkan setiap atribut tunggal. Kita sekarang membutuhkan kelas

SmtpService untuk mengirimkan Objek Email:

Line 1 #ifndef __SMTP_SERVICE__H_

- #define __SMTP_SERVICE__H_

-

- #include”email.h"

5

- class SmtpService{

- byte* _smtp_server;

- unsigned int _port;

-

10 void read_response(Client& client){

- delay(4000);

- while (client.available()){

- const char c = client.read();

- Serial.print(c);

109

15 }

- }

-

- void send_line(Client& client, String line){

- const unsigned int MAX_LINE = 256;

20 char buffer[MAX_LINE];

- line.toCharArray(buffer, MAX_LINE);

- Serial.println(buffer);

- client.println(buffer);

- read_response(client);

25 }

-

- public:

-

- SmtpService(

30 byte* smtp_server,

- const unsigned int port) : _smtp_server(smtp_server),

- _port(port) {}

-

- void send_email(const Email& email){

35 Client client(_smtp_server, _port);

- Serial.print("Connecting...");

-

- if (!client.connect()){

- Serial.println("connection failed.");

40 } else{

- Serial.println("connected.");

- read_response(client);

- send_line(client, String("helo"));

- send_line(

45 client,

- String("mail from: <") + email.getFrom() + String(">")

110

- );

- send_line(

- client,

50 String("rcpt to: <") + email.getTo() + String(">")

- );

- send_line(client, String("data"));

- send_line(client, String("from:”) + email.getFrom());

- send_line(client, String("to:”) + email.getTo());

55 send_line(client, String("subject:”) + email.getSubject());

Harus diakui, ini adalah banyak kode, tapi itu sangat sederhana. Pertama,

SmtpService yang kelas merangkum alamat IP SMTP server dan port -nya.

Untuk berkomunikasi dengan server SMTP, kita harus membaca responnya, dan

kita melakukan itu menggunakan read_response swasta ( ) metode mulai baris 10.

Ini menunggu selama empat detik ( server SMTP biasanya sangat sibuk, karena

mereka harus mengirim banyak spam ), dan kemudian membaca semua data

dikirim kembali oleh server dan output ke port serial untuk debugging

tujuan.

Sebelum kita dapat memproses tanggapan, kita harus mengirim

permintaan. send_line ( ) dimulai pada baris 18 mengirimkan satu perintah ke

server SMTP. Anda harus melewati koneksi ke server sebagai contoh Client, dan

baris Anda ingin mengirim harus menjadi obyek String. Untuk mengirim data

yang tersimpan dalam sebuah objek String, kita perlu mengakses karakter

Data mengacu pada. Pada saat penulisan ini, referensi Arduino dokumentasi

memberitahu Anda untuk hanya menggunakan toCharArray ( ) atau getBytes ()

untuk mengambil informasi ini.

Sayangnya, dokumentasi yang salah.

Artinya, kedua metode ini tidak mengembalikan sebuah pointer. Sebaliknya,

mereka mengharapkan Anda untuk memberikan array char cukup besar dan

ukurannya. Itu sebabnya kita konten copy baris untuk penyangga sebelum output

kita ke serial dan Ethernet pelabuhan. Setelah kita telah mengirim data, kita

membaca respon server dan mencetaknya ke port serial. Dalam antarmuka publik,

111

Anda tidak menemukan kejutan. Konstruktor mengharapkan alamat IP SMTP

server dan port -nya. Send_email The ( ) Metode adalah bagian terbesar dari kode

di kelas kita, tapi itu juga salah satu yang sederhana. Ini meniru persis sesi telnet

kita, dan satu-satunya hal yang layak disebutkan adalah penanganan string : kita

menggunakan new class String Arduino itu, dan menggunakan operator

concatenation nya ( + ), kita mengubah setiap string menjadi

Object String.

Mari kita gunakan kelas kita sekarang untuk benar-benar mengirim email :

Line 1 #include <SPI.h>

- #include <Ethernet.h>

- #include”smtp_service.h"

-

5 const unsigned int SMTP_PORT = 25;


-

- byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

- byte my_ip[] = { 192, 168, 2, 120 };

10

- // Insert IP of your SMTP server below!

- byte smtp_server[] = { 0, 0, 0, 0 };

-

- SmtpService smtp_service(smtp_server, SMTP_PORT);

15

- void setup(){

- Ethernet.begin(mac, my_ip);


- delay(1000);

20 Email email(

-”[email protected]",


112

-”Yet another subject",

-”Yet another body"

25 );

- smtp_service.send_email(email);

- }

-

- void loop() {}

Tidak ada kejutan di sini. Kita mendefinisikan konstanta, alamat MAC,

dan sebagainya, kemudian membuat sebuah contoh SmtpService. Dalam setup ()

fungsi, kita menginisialisasi port serial dan perisai Ethernet, kemudian menunggu

untuk kedua untuk membiarkan hal menetap sedikit. Pada baris 20, kita membuat

objek baru dan Email panggilan send_email nya () method. Sekarang kita tahu

cara mengirim email dengan Arduino, tetapi untuk membangun kita alarm

pencuri, kita masih harus belajar bagaimana untuk mendeteksi gerakan.

6.8 Mendeteksi Gerak Menggunakan Passive Infrared Sensor

Mendeteksi gerakan adalah teknik yang berguna, dan Anda mungkin

sudah tahu perangkat yang menyalakan lampu di kebun atau di depan pintu Anda

setiap kali seseorang cukup dekat. Sebagian besar dari mereka menggunakan

sensor inframerah pasif (PIR) 15 untuk mendeteksi gerakan.

Hampir setiap objek memancarkan cahaya inframerah, dan sensor PIR

langkah-langkah persis bagian ini cahaya. Mendeteksi gerakan adalah relatif

mudah jika Anda sudah dapat menerima radiasi inframerah dipancarkan oleh

benda-benda di lapangan sensor pandang. Jika sensor menerima cahaya

inframerah yang dipancarkan oleh dinding, misalnya, dan tiba-tiba manusia

sedang atau binatang bergerak di depan dinding, sinyal cahaya inframerah akan

berubah. Off - the- shelf sensor menyembunyikan rincian ini, sehingga Anda

dapat menggunakan single digital pin untuk memeriksa apakah seseorang

bergerak di lapangan sensor pandang.

113

Sensor Parallax PIR16 adalah contoh yang baik dari alat tersebut, dan kita

akan menggunakannya sebagai dasar alarm pencuri kita. Sensor PIR memiliki tiga

pin : kekuasaan, tanah, dan sinyal. Menghubungkan listrik ke Arduino yang 5V

pasokan, tanah untuk salah satu GND Arduino ini pin, dan sinyal untuk pin digital

2. Sensor ini juga memiliki jumper yang dapat Anda gunakan untuk mengubah

perilakunya. Untuk proyek kita, itu harus dalam posisi H ; yaitu, jumper harus

menutupi pin di sebelah H.

Kemudian masukkan kode berikut di Arduino IDE :

Line 1 const unsigned int PIR_INPUT_PIN = 2;


-

- class PassiveInfraredSensor{

5 int _input_pin;

-

- public:

-

- PassiveInfraredSensor(const int input_pin){

10 _input_pin = input_pin;

- pinMode(_input_pin, INPUT);

- }

-

- const bool motion_detected() const{

15 return digitalRead(_input_pin) == HIGH;

- }

- };

-

- PassiveInfraredSensor pir(PIR_INPUT_PIN);

20

- void setup(){


114

- }

-

25 void loop(){

- if (pir.motion_detected()){

- Serial.println("Motion detected");

- } else{

- Serial.println("No motion detected");

30 }

- delay(200);

- }

Dengan PIR_INPUT_PIN konstan, Anda dapat menentukan pin digital

Anda sudah Koneksi sensor PIR untuk. Sejalan 4, kita mulai definisi

kelas bernama PassiveInfraredSensor yang merangkum semua hal yang berkaitan

dengan Sensor PIR.

Kita mendefinisikan anggota variabel bernama _input_pin yang

menyimpan nomor pin digital kita sudah terhubung sensor kita. Kemudian kita

mendefinisikan konstruktor yang mengharapkan nomor pin sebagai argumen dan

memberikan ke variabel anggota kita.

Satu-satunya metode kita perlu mendefinisikan adalah motion_detected ( ).

Itu mengembalikan nilai true jika saat ini telah mendeteksi gerak dan fal se

sebaliknya. Jadi, itu harus periksa apakah hanya keadaan saat pin digital sensor

TINGGI atau LOW.

Kompilasi sketsa, meng-upload ke Arduino Anda, ketika Anda mulai

gelombang dengan tangan Anda di depan sensor. Sekarang kita telah membangun

dua komponen utama alarm pencuri kita, dan satu-satunya yang tersisa untuk

dilakukan adalah untuk membawa mereka berdua bersama-sama. Kita akan

melakukan itu dalam bagian berikutnya.

115

6.9 Menyatukan Semuanya

Dengan kita PassiveInfraredSensor dan SmtpService kelas, sangat mudah

untuk membangun sebuah alarm pencuri email. Hubungkan sensor PIR ke

Ethernet perisai dan upload kode berikut untuk Arduino Anda :

Line 1 #ifndef __BURGLAR_ALARM_H__

- #define __BURGLAR_ALARM_H__

-

- #include”pir_sensor.h"

5 #include”smtp_service.h"

-

- class BurglarAlarm{

- PassiveInfraredSensor _pir_sensor;

- SmtpService _smtp_service;

10

- void send_alarm(){

- Email email(



15”Intruder Alert!",

-”Someone's moving in your living room!"

- );

- _smtp_service.send_email(email);

- }

20

- public:

-

- BurglarAlarm(

- const PassiveInfraredSensor& pir_sensor,

25 const SmtpService& smtp_service):

- _pir_sensor(pir_sensor),

- _smtp_service(smtp_service)

116

- {

- }

30

- void check(){

- Serial.println("Checking");

- if (_pir_sensor.motion_detected()){

- Serial.println("Intruder detected!");

35 send_alarm();

- }

- }

- };

-

40 #endif

Ini mendefinisikan kelas bernama BurglarAlarm yang mengumpulkan

semua kode kita telah menulis sejauh ini. Ini merangkum contoh SmtpService dan

PassiveInfraredSensor a objek. Metode yang paling kompleks adalah send_alarm

() yang mengirimkan email yang telah ditetapkan.

Sisa kelas BurglarAlarm adalah cukup sederhana. awal sejalan 23, kita

mendefinisikan konstruktor yang menginisialisasi semua anggota pribadi. Cek ()

metode cek apakah sensor PIR telah mendeteksi gerakan. Jika tidak, kita

mengirim email.

Mari kita gunakan kelas BurglarAlarm:

#include <SPI.h>

#include <Ethernet.h>

#include”burglar_alarm.h"

const unsigned int PIR_INPUT_PIN = 2;

const unsigned int SMTP_PORT = 25;


byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

117

byte my_ip[] = { 192, 168, 2, 120 };

// Insert IP of your SMTP server below!

byte smtp_server[] = { 0, 0, 0, 0 };

PassiveInfraredSensor pir_sensor(PIR_INPUT_PIN);

SmtpService smtp_service(smtp_server, SMTP_PORT);

BurglarAlarm burglar_alarm(pir_sensor, smtp_service);

void setup(){

Ethernet.begin(mac, my_ip);


delay(20 * 1000);

}

void loop() {

burglar_alarm.check();

delay(3000);

}

Pertama kita mendefinisikan semua library yang kita butuhkan, dan kita

mendefinisikan konstanta untuk PIR sensor pin dan alamat MAC kita. Kemudian

kita mendefinisikan SmtpService dan PassiveInfraredSensor benda dan

menggunakannya untuk mendefinisikan sebuah BurglarAlarm misalnya.

Dalam metode setup (), kita mendefinisikan port serial dan perisai

Ethernet. Saya juga telah menambahkan penundaan dua puluh detik, yang

memberikan Anda cukup waktu untuk meninggalkan ruangan sebelum alarm

mulai bekerja. Loop ( ) fungsi sederhana, juga. Ini delegasi semua pekerjaan ke

Burglar Kita sudah rapi menyembunyikan kompleksitas kedua email dan

sensor PIR di dua kelas kecil. Untuk membangun alarm pencuri, kita kemudian

hanya harus menulis beberapa kode lem.

Satu kata mengenai privasi : tidak menyalahgunakan proyek dalam bab ini

untuk mengamati orang lain tanpa sepengetahuan mereka. Tidak hanya itu tidak

etis, tetapi di banyak negara bahkan adalah ilegal!

Dalam bab ini, Anda belajar cara yang berbeda untuk menghubungkan

Arduino ke Internet. Beberapa dari mereka membutuhkan PC tambahan,

118

sementara yang lain perlu perisai Ethernet, tetapi mereka semua membuka pintu

untuk berbagai baru dari aplikasi komputasi embedded. Networking adalah salah

satu teknik yang mungkin memiliki dampak langsung

pada dunia luar. Dalam bab berikutnya, Anda akan belajar tentang yang lain

teknik yang memiliki efek yang serupa, Anda akan belajar bagaimana untuk

mengontrol perangkat

jarak jauh.


Jaringan adalah sesuatu yang kompleks dan rumit, dan banyak hal bisa

salah ketika mencoba contoh dalam bab ini. Yang paling umum

masalah adalah sebagai berikut :

• Anda telah memilih port serial yang salah dalam aplikasi Processing.

Secara default, aplikasi menggunakan port serial pertama dapat

menemukan. Mungkin saja Anda telah menghubungkan Arduino Anda yang lain

pelabuhan. Dalam hal ini, Anda harus mengubah indeks 0 dalam pernyataan

arduinoPort = new Serial ( ini, Serial.list ( ) [ 0 ], BAUD_RATE ) ; sesuai.

• Anda lupa pasang kabel Ethernet ke dalam perisai Ethernet.

• jaringan router Anda memiliki daftar putih MAC yang memungkinkan tertentu

saja Alamat MAC untuk mengakses jaringan. Pastikan bahwa alamat MAC Anda

gunakan dalam sketsa Anda masuk daftar putih. Periksa Anda dokumentasi router.

• Anda telah menggunakan alamat MAC yang sama dua kali pada jaringan Anda.

• Anda telah menggunakan alamat IP yang tidak diperbolehkan dalam jaringan

Anda atau yang digunakan sudah oleh perangkat lain. Periksa kembali IP Anda

alamat.

• Anda telah menggunakan perintah yang salah untuk mengakses layanan seperti

Twitter. Pastikan Anda menggunakan token OAuth yang tepat.

• Twitter tidak memungkinkan duplikat tweet. Jadi, setiap kali aplikasi Anda

gagal men-tweet pesan, pastikan Anda tidak tweeted itu

119

baru-baru ini.

• Networks telah menjadi sangat handal selama dekade terakhir, namun

kadang-kadang mereka masih agak rapuh. Jadi, mungkin saja bahwa koneksi

gagal atau bahwa Anda mengalami timeout. Meningkatkan keterlambatan

sketsa yang sesuai.

6.11 Latihan

• Pencarian Kita b untuk proyek-proyek Ethernet shield lainnya, dan membangun

di setidaknya satu dari mereka. Sebagai contoh, Anda dapat menemukan chat

klien untuk Arduino.18

• Membangun sebuah proyek yang mirip dengan alarm pencuri, tapi

menggunakan jenis lain

dari sensor. Ada ton inspirasi di luar sana di Kita b. 19

• Tambahkan cap waktu saat ini untuk email alarm pencuri itu. Dapatkan

timestamp dari layanan SIANG.

cxx

Daftar Pustaka Website :

http://arduino.cc

http://fritzing.org/

http://arduino.cc/blog/2010/01/01/uno-punto-zero/

http://code.google.com/p/arduino/issues/list?q=milestone=1.0

http://processing.org

http://www.pragprog.com/titles/msard/errata

http://flickr.com

http://makershed.com

http://adafruit.com

http://radioshack.com

http://digikey.com

http://sparkfun.com

http://mouser.com

http://www.analog.com/en/sensors/digital-temperature-

sensors/tmp36/products/product.html

http://arduino.cc/en/uploads/Main/arduino-uno-schematic.pdf

http://arduino.cc/en/Main/Boards

http://arduino.cc/en/Main/ArduinoBoardLilyPad

http://arduino.cc/

http://fritzing.org/

http://arduino.cc/blog/2010/01/01/uno-punto-zero/

http://code.google.com/p/arduino/issues/list?q=milestone=1.0

http://processing.org/

http://www.pragprog.com/titles/msard/errata

http://flickr.com/

http://makershed.com/

http://adafruit.com/

http://radioshack.com/

http://digikey.com/

http://sparkfun.com/

http://mouser.com/

http://www.analog.com/en/sensors/digital-temperature-sensors/tmp36/products/product.html

http://www.analog.com/en/sensors/digital-temperature-sensors/tmp36/products/product.html

http://arduino.cc/en/uploads/Main/arduino-uno-schematic.pdf

http://arduino.cc/en/Main/Boards

http://arduino.cc/en/Main/ArduinoBoardLilyPad

cxxi

Buku :

Paul Butcher. Debug It!: Find, Repair, and Prevent Bugs in

Your Code. The Pragmatic Programmers, LLC, Raleigh, NC,

and Dallas, TX, 2009.

Ira Greenberg. Processing: Creative Coding and Computational

Art. Apress, Berkeley, CA, USA, 2007.

Brian W. Kernighan and Dennis Ritchie. The C Programming

Language. Prentice Hall PTR, Englewood Cliffs, NJ, second

edition, 1998.

Scott Meyers. Effective C++: 50 Specific Ways to Improve Yo ur

Programs and Designs. Addison Wesl ey Longman, Reading,

MA, second edition, 1997.

Chris Pine. Learn to Program. The Pragmatic Programmers,

LLC, Raleigh, NC, and Dallas, TX, 2006.

Charles Platt. Make: Electronics. O’Reilly Media, Inc.,

Sebastopol, CA, 2010.

Bjarne Stroustrup. The C++ Programming Language. Addison

Wesl ey Longman, Reading, MA, 2000.

cxxii

Lampiran

Nama Lengkap : Muhammad Bangun Agung

NIM : 202136575862733

Nama Dosen : Onno W. Purbo

Kampus : Surya Unversity