Selepas membiasakan diri dengan elemen asas Arduino, serta menulis program "Hello World!". Sudah tiba masanya untuk membiasakan diri dengan bahasa pengaturcaraan.
Struktur bahasa adalah berdasarkan terutamanya pada C/C++, jadi mereka yang sebelum ini telah memprogramkan dalam bahasa ini tidak akan mengalami kesukaran untuk belajar pengaturcaraan Arduino. Orang lain harus mempelajari maklumat asas tentang arahan kawalan, jenis data dan fungsi.
Kebanyakan maklumat yang terkandung di sini akan serasi dengan mana-mana kursus C/C++, dengan mengambil kira perbezaan dalam jenis data, serta beberapa arahan khusus berkenaan pengaturcaraan port I/O.
Asas
Beberapa perkara formal, iaitu, yang semua orang tahu, tetapi kadang-kadang terlupa...
Dalam Arduino IDE, seperti dalam C/C++, anda perlu mengetahui kes aksara. Kata kunci, seperti jika, untuk sentiasa ditulis dalam huruf kecil. Setiap arahan diakhiri dengan ";". Titik koma memberitahu pengkompil bahagian mana yang hendak ditafsirkan sebagai arahan.
Tanda kurung (..) digunakan untuk menandakan blok program. Kami menggunakannya untuk mengekang badan fungsi (lihat di bawah), gelung dan pernyataan bersyarat.
Ia adalah amalan yang baik untuk menambah komen pada kandungan program, ini menjadikan kod mudah difahami. Komen satu baris bermula dengan // (seratan dua kali). Komen berbilang baris bermula dengan /* dan berakhir dengan */
Jika kami ingin memasukkan mana-mana perpustakaan dalam program kami, kami menggunakan perintah include. Berikut ialah contoh menghubungkan perpustakaan:
#termasuk
Fungsi dalam Arduino
Fungsi (subrutin) ialah bahagian berasingan program yang melaksanakan operasi tertentu. Fungsi digunakan untuk memudahkan program utama dan meningkatkan kebolehbacaan kod. Ia berguna untuk menggunakan fungsi kerana kami boleh menggunakannya dengan mudah dalam kebanyakan projek kami.
Kursus pengaturcaraan standard mengandungi maklumat tentang fungsi yang akan dibentangkan dalam artikel berikut. Dalam kes Arduino, fungsi akan dibincangkan pada mulanya kerana walaupun program paling mudah mesti mempunyai dua fungsi khas. Ini telah disebutkan dalam artikel sebelumnya, tetapi di sini kami menyusun maklumat ini.
Pengisytiharan Fungsi
Gambar rajah pengisytiharan fungsi kelihatan seperti ini:
Taip function_name(parameter) ( // arahan untuk pelaksanaan (function body) return (/* return value*/); )
menaip adalah nama sesiapa sahaja jenis yang tersedia data pada bahasa yang diberikan pengaturcaraan. Kami akan menyediakan senarai jenis yang tersedia apabila memprogramkan Arduino dalam artikel berasingan.
Selepas pelaksanaan, fungsi akan mengembalikan nilai jenis yang diisytiharkan. Jika fungsi tidak menerima sebarang nilai pulangan, maka jenis data akan menjadi "kosong".
nama_fungsi membolehkan ia dikenal pasti secara unik. Untuk memanggil (menjalankan) fungsi, kami memberikannya nama.
parameter— parameter panggilan fungsi. Parameter tidak diperlukan, tetapi ia sering berguna. Jika kita menulis fungsi yang tidak mempunyai hujah, kita biarkan kurungan kosong.
Di dalam kurungan “(…)” ialah badan sebenar fungsi atau arahan yang ingin kita laksanakan. Kami akan memberikan penerangan tentang arahan khusus dalam artikel berasingan.
Semua fungsi yang mengembalikan nilai berakhir dengan pernyataan pulangan diikuti dengan nilai pulangan. Hanya fungsi yang diisytiharkan dengan penuding nol ("kosong") tidak mengandungi penyataan pemulangan. Anda perlu tahu bahawa pernyataan pulangan menamatkan fungsi tanpa mengira lokasi.
Di bawah adalah beberapa contoh pengisytiharan fungsi.
Void f1() ( //function body) —————————————— int tolak() ( //function body return (0); ) ——————————— ——— int tambah(int a, int b) ( kembali (a+b); )
Seperti yang anda lihat dalam contoh, pengisytiharan fungsi boleh diambil pelbagai bentuk bergantung pada keperluan anda.
Kami amat mengesyorkan agar anda mempelajari dan menggunakan fungsi semasa menulis program sendiri. Dari masa ke masa, setiap pengaturcara mendapat keuntungan perpustakaan sendiri berfungsi "untuk semua keadaan", yang menjadikannya lebih mudah dan cepat untuk menulis program baharu.
Sekarang kita tahu cara menulis fungsi kita sendiri, kita perlu belajar cara menggunakannya.
Memanggil fungsi
Kami menulis semua fungsi dalam satu fail/program. Sudah tentu ada lagi penyelesaian yang elegan, tetapi kami akan cuba menerangkannya pada masa akan datang.
Sebaik sahaja kami mengisytiharkan fungsi, kami boleh menggunakannya dalam fungsi lain dengan nama yang sesuai dan sebarang parameter yang diperlukan. Di bawah adalah contoh memanggil fungsi yang kami berikan di atas:
F1(); tambah(2,2); y=tambah(1.5);
Seperti yang anda lihat dalam contoh, panggilan fungsi dibuat dengan menyatakan namanya dan bilangan parameter yang diperlukan. Adalah penting untuk sentiasa memanggil fungsi seperti yang diisytiharkan.
Jika fungsi f1() diisytiharkan tanpa parameter, maka tiada parameter boleh ditentukan semasa memanggilnya, i.e. memanggil f1(0) akan menjadi salah.
Fungsi tambah(int a, int b) memerlukan tepat dua parameter, jadi panggilan dengan satu atau tiga parameter tidak boleh dilakukan.
Memanggil y=plus(1,5) akan melaksanakan fungsi "tambah" dengan parameter "1" dan "5" dan menyimpan nilai pulangan dalam pembolehubah "y".
setup() dan fungsi loop().
Dengan pengetahuan tentang mengisytiharkan dan memanggil fungsi, kita boleh beralih ke sistem Fungsi Arduino: persediaan() Dan gelung(). Arduino IDE diperlukan untuk mengisytiharkan kedua-dua fungsi ini.
setup() ialah fungsi yang dipanggil secara automatik apabila kuasa dihidupkan atau butang RESET ditekan.
Seperti namanya, ia digunakan untuk menetapkan nilai awal pembolehubah, pengisytiharan input dan output sistem, yang biasanya dinyatakan dalam parameter awal. Disebabkan kekhususannya, fungsi ini tidak mengembalikan nilai dan tidak dipanggil dengan parameter. Perisytiharan fungsi setup() yang betul adalah di bawah:
Persediaan batal () ( // badan fungsi - permulaan sistem )
loop() ialah fungsi yang dipanggil dalam gelung tak terhingga. Fungsi ini juga tidak mengembalikan nilai dan tidak dipanggil dengan parameter. Iklan yang betul ditunjukkan di bawah fungsi gelung():
Gelung kosong () ( // badan fungsi - kod program )
Seperti yang anda lihat, pengisytiharan fungsi gelung() adalah sama dengan pengisytiharan fungsi persediaan(). Perbezaannya terletak pada prestasi fungsi ini oleh mikropengawal.
Kami kini akan menganalisis pseudokod berikut:
Persediaan batal () ( on_led1 (); //hidupkan led1 off_led1 (); //matikan led1) gelung void () ( on_led2 (); //hidupkan led2 off_led2 (); //matikan led2)
Terdapat dua arahan dalam fungsi persediaan(): yang pertama menghidupkan led1 yang disambungkan ke papan (cth. pin 13) dan yang kedua mematikan led1.
Fungsi gelung() mempunyai arahan yang sama untuk menghidupkan dan mematikan LED2 yang disambungkan ke papan (cth. pin 12).
Hasil daripada menjalankan program, led1 akan berkelip sekali, manakala led2 akan menyala dan padam selagi Arduino dihidupkan.
Menekan butang RESET akan menyebabkan led1 berkelip sekali lagi dan led2 berkelip secara berterusan sekali lagi.
ringkaskan:
- Fungsi persediaan() dan gelung() ialah fungsi sistem yang mesti ditakrifkan dalam setiap projek. Walaupun dalam keadaan di mana kita tidak menulis sebarang kod dalam salah satu daripadanya, kita masih perlu mengisytiharkan kedua-dua fungsi ini;
- Fungsi persediaan() dilaksanakan sekali, gelung() dilaksanakan secara berterusan;
- Kami mencipta fungsi kami sendiri dalam satu fail;
- Kita boleh memanggil fungsi kita dari setup() dan loop(), dan dari fungsi lain;
- Fungsi kita sendiri boleh dipanggil dengan parameter dan mengembalikan nilai;
- Panggilan fungsi mesti dibuat mengikut pengisytiharannya.
Anda telah menjadi pemilik bangga papan Arduino. Apa yang perlu dilakukan seterusnya? Dan kemudian anda perlu menyambungkan Arduino dengan komputer. Kami akan melihat untuk memulakan dengan Arduino Uno masuk sistem operasi Windows.
1. Memasang Arduino IDE
Mula-mula anda perlu memasang persekitaran bersepadu pada komputer anda pembangunan Arduino- Arduino IDE.
Memasang IDE Arduino menggunakan pemasang akan menyelamatkan anda daripada kebanyakan masalah yang berpotensi dengan pemacu dan persekitaran perisian.
2. Lancarkan Arduino IDE
Sebaik sahaja anda memuat turun dan memasang IDE Arduino, mari jalankan ia!
Di hadapan kita ialah tetingkap IDE Arduino. Sila ambil perhatian - kami belum lagi menyambungkan kami Papan Arduino Uno ke komputer, dan di sudut kanan bawah sudah ada tulisan "Arduino Uno pada COM1". Oleh itu, Arduino IDE memberitahu kita bahawa dalam masa ini ia dikonfigurasikan untuk berfungsi dengan papan sasaran Arduino Uno. Dan apabila tiba masanya, Arduino IDE akan mencari Arduino Uno pada port COM1.
Kami akan menukar tetapan ini kemudian.
Ada masalah?
Arduino IDE tidak akan bermula? JRE mungkin dipasang secara salah pada komputer anda ( Java Runtime Persekitaran). Rujuk titik (1) untuk memasang semula IDE Arduino: pemasang akan melakukan semua kerja menggunakan JRE.
3. Menyambung Arduino ke komputer
Selepas memasang Arduino IDE, sudah tiba masanya untuk menyambungkan Arduino Uno ke komputer anda.
Sambungkan Arduino Uno ke komputer anda melalui kabel USB. Anda akan melihat LED "HIDUP" pada papan menyala dan LED "L" akan mula berkelip. Ini bermakna bahawa papan dikuasakan dan Pengawal mikro Arduino Uno mula melaksanakan program "Blink" yang diprogramkan oleh kilang (mengelipkan LED).
Untuk mengkonfigurasi IDE Arduino untuk berfungsi dengan Arduino Uno, kita perlu mengetahui nombor port COM yang telah diberikan oleh komputer Arduino Uno. Untuk melakukan ini, pergi ke Pengurus Peranti Windows dan buka tab "Pelabuhan (COM dan LPT)". Kita harus melihat gambar berikut:
Ini bermakna sistem pengendalian mengiktiraf papan Arduino Uno kami sebagai port COM, memilih pemacu yang betul untuknya dan menetapkan nombor port COM ini 7. Jika kami menyambungkan papan Arduino lain ke komputer, sistem pengendalian akan memberikannya nombor yang berbeza. Oleh itu, jika anda mempunyai beberapa papan Arduino, adalah sangat penting untuk tidak keliru tentang nombor port COM.
Ada masalah?
4. Mengkonfigurasi Arduino IDE untuk berfungsi dengan Arduino Uno
Sekarang kita perlu memberitahu Arduino IDE bahawa papan yang akan berkomunikasi dengannya adalah pada port COM "COM7".
Untuk melakukan ini, pergi ke menu "Perkhidmatan" → "Serial Port" dan pilih port "COM7". Sekarang Arduino IDE tahu bahawa ada sesuatu pada port "COM7". Dan dia tidak lama lagi perlu berkomunikasi dengan "sesuatu" ini.
Agar Arduino IDE tidak mempunyai keraguan, adalah perlu untuk menunjukkan secara langsung: "Kami akan menggunakan Arduino Uno!" Untuk melakukan ini, pergi ke menu "Alat" → "Papan" dan pilih "Arduino Uno" kami.
Ada masalah?
Adakah senarai port bersiri kosong? Ini bermakna Arduino Uno tidak disambungkan dengan betul. Kembali ke langkah (3) untuk nyahpepijat sambungan.
Arduino IDE sangat perlahan semasa menavigasi menu? Lumpuhkan segala-galanya dalam Pengurus Peranti peranti luaran taip "Bersiri Bluetooth". Sebagai contoh, peranti maya untuk menyambung dengan telefon mudah alih melalui Bluetooth boleh menyebabkan tingkah laku ini.
Persekitaran dikonfigurasikan, papan disambungkan. Kini anda boleh meneruskan untuk memuat naik lakaran.
Arduino IDE mengandungi banyak contoh siap sedia, di mana anda boleh melihat penyelesaian masalah dengan cepat. Ia juga mengandungi contoh mudah "Blink". Jom pilih.
Jom ubah suai kod sikit untuk nampak perbezaan dengan LED kilang berkelip.
Daripada baris:
Kelewatan(1000);
Kelewatan(100);
Versi penuh kod:
/* Berkelip Menghidupkan LED selama satu saat, kemudian mematikan selama satu saat, berulang kali. Kod contoh ini adalah dalam domain awam. */ // Pin 13 mempunyai LED yang disambungkan pada kebanyakan papan Arduino.// beri nama: int led = 13 ; // rutin persediaan berjalan sekali apabila anda menekan set semula: persediaan batal() ( // mulakan pin digital sebagai output. pinMode(led, OUTPUT) ; ) // rutin gelung berjalan berulang kali selama-lamanya: void loop() ( digitalWrite(led, HIGH) ; // hidupkan LED (TINGGI ialah paras voltan) kelewatan(100); // tunggu untuk digitalWrite(led, LOW) kedua; // matikan LED dengan menjadikan voltan RENDAH kelewatan(100); // tunggu sebentar)
LED "L" kini sepatutnya menyala dan padam selama sepersepuluh saat. Itu 10 kali lebih cepat daripada versi kilang.
Mari muat naik lakaran kami ke Arduino Uno dan semak sama ada ini benar? Selepas but, LED akan mula berkelip lebih cepat. Ini bermakna semuanya berjaya. Kini anda boleh beralih ke "Eksperimen" dengan selamat
Ada masalah?
Hasil daripada muat turun, ralat seperti avrdude muncul: stk500_get sync(): not in sync: resp = 0x00 ? Ini bermakna Arduino tidak dikonfigurasikan dengan betul. Kembali ke langkah sebelumnya untuk memastikan bahawa peranti telah dikenali oleh sistem pengendalian dan tetapan yang betul untuk port COM dan model papan ditetapkan dalam IDE Arduino.
Satu siri artikel dan gambar rajah latihan dengan eksperimen radio amatur pada Arduino untuk pemula. Ini adalah sejenis mainan pembinaan radio amatur, dari mana, tanpa besi pematerian, etsa papan litar bercetak dan seumpamanya, mana-mana penggemar elektronik boleh memasang peranti berfungsi sepenuhnya, sesuai untuk kedua-dua prototaip profesional dan eksperimen amatur dalam kajian elektronik.
Papan Arduino bertujuan terutamanya untuk mengajar amatur radio pemula asas-asas pengaturcaraan mikropengawal dan mencipta peranti mikropengawal dengan tangan mereka sendiri tanpa latihan teori yang serius. Persekitaran pembangunan Arduino membolehkan anda menyusun dan memuatkan kod program siap sedia ke dalam memori papan. Selain itu, memuatkan kod adalah sangat mudah.
Arduino di mana untuk bermula untuk pemula |
Pertama sekali, untuk bekerja dengan papan Arduino, seorang jurutera elektronik pemula perlu memuat turun program pembangunan Arduino; ia terdiri daripada editor teks terbina dalam di mana kami bekerja dengan kod program, kawasan mesej, tetingkap output teks (konsol ), bar alat dengan butang untuk arahan yang kerap digunakan dan beberapa menu. Untuk memuat turun program anda dan berkomunikasi, program ini adalah melalui standard kord USB menyambung ke papan Arduino.
Kod yang ditulis dalam persekitaran Arduino dipanggil lakaran. Ia ditulis dalam penyunting teks mempunyai alat khas memasukkan/memotong, menggantikan/mencari teks. Semasa menyimpan dan mengeksport, penjelasan muncul dalam kawasan mesej (lihat gambar dalam pelajaran pertama untuk pemula, betul-betul di bawah), dan ralat juga mungkin dipaparkan. Konsol memaparkan mesej Arduino, termasuk laporan ralat penuh dan maklumat berguna lain. Butang bar alat membolehkan anda menyemak dan merekodkan lakaran, membuka, mencipta dan menyimpannya, membuka pemantauan bas bersiri dan banyak lagi.
Jadi mari kita beralih kepada yang pertama. Pelajaran Arduino gambar rajah litar untuk jurutera elektronik pemula.
Pengawal Arduino UNO untuk kemudahan pemula, ia sudah mempunyai rintangan dan LED yang disambungkan ke pin 13 penyambung, jadi kami tidak memerlukan sebarang elemen radio luaran dalam percubaan pertama.
Dengan memuatkan kod, Arduino membenarkan program kami mengambil bahagian dalam pemulaan sistem. Untuk melakukan ini, kami menunjukkan kepada arahan mikropengawal bahawa ia akan dilaksanakan pada masa boot awal dan kemudian melupakannya sepenuhnya (iaitu, arahan ini akan dilaksanakan oleh Arduino hanya sekali pada permulaan). Dan untuk tujuan ini, dalam kod kami, kami memilih blok di mana arahan ini disimpan. persediaan batal(), atau sebaliknya dalam ruang di dalam pendakap kerinting fungsi ini, lihat lakaran atur cara.
Jangan lupa tentang pendakap gigi! Kehilangan sekurang-kurangnya satu daripadanya akan menjadikan keseluruhan lakaran tidak dapat dilaksanakan sepenuhnya. Tetapi jangan letakkan kurungan tambahan sama ada, kerana ini juga akan menyebabkan ralat.
| Muat turun kod:
|
Fungsi gelung kosong() di sinilah kita meletakkan arahan yang akan dilaksanakan selagi Arduino dihidupkan. Setelah memulakan pelaksanaan dari arahan pertama, Arduino akan mencapai penghujung dan segera pergi ke permulaan untuk mengulangi urutan yang sama. Jadi nombor tak terhingga kali, selagi lembaga menerima kuasa. Pada terasnya, gelung lompang adalah fungsi utama, titik masuk ke Arduino.
Fungsi kelewatan(1000) menangguhkan pemprosesan program sebanyak 1000 milisaat. Semuanya berjalan dalam kitaran yang kekal gelung().
Kesimpulan utama selepas memahami program pertama kami pada Arduino: Dengan menggunakan fungsi kosong gelung dan persediaan lompang kami menghantar arahan kami kepada mikropengawal. Semua yang ada di dalam blok persediaan akan dilaksanakan sekali sahaja. Kandungan modul gelung akan diulang dalam gelung selagi Arduino kekal dihidupkan.
DALAM program sebelumnya Terdapat kelewatan kedua antara menghidupkan dan mematikan LED. Terdapat satu tolak besar dalam kod paling mudah bagi pengendali Arduino pemula yang digunakan di atas. Untuk mengekalkan jeda antara menghidupkan dan mematikan LED selama satu saat, kami menggunakan fungsi tersebut kelewatan() dan oleh itu pada masa ini pengawal tidak mampu melaksanakan arahan lain dalam fungsi utama gelung(). Membetulkan kod dalam fungsi gelung(), dibentangkan di bawah menyelesaikan masalah ini.
Daripada menetapkan nilai kepada HIGH dan kemudian kepada RENDAH, kita akan mendapat nilai ledPin dan terbalikkannya. Katakan jika ia TINGGI, ia akan menjadi RENDAH, dsb.
Kedua Pilihan kod Arduino untuk kawalan LED di sini:
Kemudian anda boleh menggantikan fungsi tersebut kelewatan(). Sebaliknya, lebih baik menggunakan fungsi tersebut millis(). Ia mengembalikan bilangan milisaat yang telah berlalu sejak program dimulakan. Fungsi akan melimpah selepas kira-kira 50 hari menjalankan kod program.
Fungsi yang serupa ialah mikro (), yang mengembalikan bilangan mikrosaat yang telah berlalu sejak kod program dilancarkan. Fungsi akan kembali kepada sifar selepas 70 minit operasi program.
Sudah tentu, ini akan menambah beberapa baris kod pada lakaran kami, tetapi ia sudah pasti akan menjadikan anda seorang pengaturcara yang lebih berpengalaman dan meningkatkan potensi Arduino anda. Untuk melakukan ini, anda hanya perlu belajar cara menggunakan fungsi millis.
Ia harus difahami dengan jelas fungsi paling mudah kelewatan menjeda pelaksanaan keseluruhan program Arduino, menjadikannya tidak dapat melaksanakan sebarang tugas dalam tempoh masa tersebut. Daripada menjeda keseluruhan program kami, kami boleh mengira berapa lama masa telah berlalu sebelum tindakan selesai. Ini, dengan baik, dilaksanakan menggunakan fungsi millis(). Untuk menjadikan segala-galanya mudah difahami, kami akan mempertimbangkan pilihan berikut untuk menyalakan LED tanpa kelewatan masa.
Permulaan program ini adalah sama seperti lakaran Arduino standard yang lain.
DALAM dalam contoh ini dua pin I/O digital Arduino digunakan. LED disambungkan ke pin 8, yang dikonfigurasikan sebagai OUTPUT. Butang disambungkan ke 9 melalui, yang dikonfigurasikan sebagai INPUT. Apabila kita menekan butang, pin 9 ditetapkan kepada HIGH, dan program menukar pin 8 kepada HIGH, dengan itu menghidupkan LED. Melepaskan butang menetapkan semula pin 9 kepada LOW. Kod kemudian menukar pin 8 kepada LOW, mematikan lampu penunjuk.
Untuk mengawal lima LED kami akan menggunakan pelbagai manipulasi dengan port Arduino. Untuk melakukan ini, kami akan terus menulis data ke port Arduino, ini akan membolehkan kami menetapkan nilai untuk LED menggunakan hanya satu fungsi.
Arduino UNO mempunyai tiga port: B(input/output digital dari 8 hingga 13); C(input analog); D(input/output digital 0 hingga 7)
Setiap port mengawal tiga daftar. DDR pertama menentukan sama ada pin akan menjadi input atau output. Menggunakan daftar PORT kedua, anda boleh menetapkan pin kepada HIGH atau LOW. Menggunakan yang ketiga, anda boleh membaca maklumat tentang keadaan kaki Arduino, jika ia berfungsi sebagai input.
Untuk mengendalikan litar, kami akan menggunakan port B. Untuk melakukan ini, kami akan menetapkan semua pin port sebagai output digital. Pelabuhan B hanya mempunyai 6 kaki. Bit daftar DDRB mesti ditetapkan kepada "1" , jika pin akan digunakan sebagai output (OUTPUT), dan masuk "0" , jika kita bercadang untuk menggunakan pin sebagai input (INPUT). Bit port bernombor 0 hingga 7, tetapi tidak selalu mempunyai semua 8 pin
Katakan: DDRB = B00111110;// tetapkan pin port B 1 hingga 5 sebagai output dan 0 sebagai input.
Dalam litar lampu larian kami, kami menggunakan lima output: DDRB = B00011111; // tetapkan pin port B 0 hingga 4 sebagai output.
Untuk menulis data ke port B, anda perlu menggunakan daftar PORTB. Anda boleh menyalakan LED pertama menggunakan pasukan pengurusan: PORTB = B00000001;, LED pertama dan keempat: PORTB = B00001001 dan sebagainya
Terdapat dua operator anjakan binari: kiri dan kanan. Operator anjakan kiri menyebabkan semua bit data bergerak ke kiri, manakala operator anjakan kanan mengalihkannya ke kanan.
Contoh:
varA = 1; // 00000001
varA = 1 varA = 1 varA = 1
Sekarang mari kita kembali ke kod sumber program kami. Kita perlu memasukkan dua pembolehubah: atas bawah akan memasukkan nilai tempat untuk bergerak - naik atau turun, dan yang kedua silon akan menunjukkan LED mana yang hendak dinyalakan.
Secara struktur, LED sedemikian mempunyai satu terminal biasa dan tiga terminal untuk setiap warna. Di bawah ialah gambar rajah menyambungkan LED RGB ke papan Arduino dengan katod biasa. Semua perintang yang digunakan dalam litar sambungan mestilah mempunyai nilai yang sama dari 220-270 Ohms.
Untuk sambungan dengan katod biasa, gambar rajah sambungan untuk LED tiga warna akan hampir sama, kecuali pin biasa akan disambungkan bukan ke tanah (gnd pada peranti), tetapi ke pin +5 volt. Pin Merah, hijau dan biru dalam kedua-dua kes disambungkan kepada output digital pengawal 9, 10 dan 11.
Kami akan menyambungkan LED luaran ke pin kesembilan Arduino UNO melalui rintangan 220 Ohms. Untuk mengawal kecerahan yang terakhir dengan lancar, gunakan fungsi tersebut analogWrite(). Ia memberikan output isyarat PWM kepada kaki pengawal. Lebih-lebih lagi, pasukan pinMode() tak perlu call. Kerana analogWrite(pin, nilai) termasuk dua parameter: pin - nombor pin untuk output, nilai - nilai dari 0 hingga 255.
Kod:
/*
Contoh tutorial untuk pembangun Arduino pemula yang mendedahkan keupayaan perintah analogWrite() untuk melaksanakan kesan Fade pada LED
*/
kecerahan int = 0; // Kecerahan LED
int fadeAmount = 5; // langkah perubahan kecerahan
Masa semasa panjang yang tidak ditandatangani;
masa gelung panjang yang tidak ditandatangani;
Persediaan batal() (
pinMode(9, OUTPUT); // tetapkan pin 9 sebagai output
currentTime = millis();
loopTime = semasaMasa;
}
Gelung tidak sah() (
currentTime = millis();
if(currentTime >= (loopTime + 20))(
analogWrite(9, kecerahan); // tetapkan nilai pada pin 9
Kecerahan = kecerahan + fadeAmount; // tambah langkah untuk menukar kecerahan, yang akan ditubuhkan dalam kitaran seterusnya
// jika mencapai min. atau maks. nilai, kemudian pergi ke sisi terbalik(terbalik):
jika (kecerahan == 0 || kecerahan == 255) (
fadeAmount = -fadeAmount ;
}
loopTime = semasaMasa;
}
}
Operasi Arduino dengan pengekod |
Pengekod direka untuk menukar sudut putaran kepada isyarat elektrik. Daripadanya kita menerima dua isyarat (A dan B), yang bertentangan dalam fasa. Dalam tutorial ini kami akan menggunakan pengekod SparkFun COM-09117, yang mempunyai dua belas kedudukan setiap pusingan (setiap kedudukan adalah tepat 30°). Rajah di bawah dengan jelas menunjukkan bagaimana output A dan B bergantung antara satu sama lain apabila pengekod bergerak mengikut arah jam atau lawan jam.
Jika isyarat A pergi dari tahap positif kepada sifar, kita membaca nilai output B. Jika output B berada dalam keadaan positif pada masa ini, maka pengekod bergerak mengikut arah jam, jika B mengeluarkan tahap sifar, maka pengekod bergerak ke arah yang bertentangan. Dengan membaca kedua-dua output, kami dapat mengira arah putaran menggunakan mikropengawal, dan dengan mengira denyutan daripada output A pengekod, sudut putaran.
Jika perlu, anda boleh menggunakan pengiraan kekerapan untuk menentukan kelajuan pengekod berputar.
Menggunakan pengekod dalam contoh tutorial kami, kami akan melaraskan kecerahan LED menggunakan output PWM. Untuk membaca data daripada pengekod, kami akan menggunakan kaedah berdasarkan pemasa perisian, yang telah kami bincangkan.
Memandangkan fakta bahawa dalam kes terpantas, kita boleh memutarkan tombol pengekod 180° dalam 1/10 saat, ini akan menjadi 6 denyutan dalam 1/10 saat atau 60 denyutan dalam satu saat.
Pada hakikatnya, tidak mungkin untuk berputar lebih cepat. Memandangkan kita perlu menjejaki semua separuh kitaran, kekerapan hendaklah kira-kira 120 Hertz. Untuk memastikan sepenuhnya, mari ambil 200 Hz.
Oleh kerana, dalam kes ini, kami menggunakan pengekod mekanikal, lantunan kenalan adalah mungkin, dan frekuensi rendah menapis dengan sempurna perbualan tersebut.
Berdasarkan isyarat pemasa program, adalah perlu untuk sentiasa membandingkan nilai semasa output pengekod A dengan nilai sebelumnya. Jika keadaan berubah daripada positif kepada sifar, maka kita meninjau keadaan keluaran B. Bergantung pada keputusan tinjauan negeri, kita menambah atau mengurangkan pembilang nilai kecerahan LED. Kod program dengan selang masa kira-kira 5 ms (200 Hz) dibentangkan di bawah:
Kod pemula Arduino:
/*
** Pengekod
** Untuk mengawal kecerahan LED, pengekod daripada Sparkfun digunakan
*/
Kecerahan int = 120; // Kecerahan LED, mulakan pada separuh
int fadeAmount = 10; // langkah perubahan kecerahan
Masa semasa panjang yang tidak ditandatangani;
masa gelung panjang yang tidak ditandatangani;
const int pin_A = 12; // pin 12
const int pin_B = 11; // pin 11
pengekod aksara tidak ditandatangani_A;
pengekod aksara tidak ditandatangani_B;
pengekod aksara tidak ditandatangani_A_prev=0;
persediaan batal() (
// mengisytiharkan pin 9 sebagai output:
pinMode(9, OUTPUT); // tetapkan pin 9 sebagai output
pinMode(pin_A, INPUT);
pinMode(pin_B, INPUT);
currentTime = millis();
loopTime = semasaMasa;
}
gelung kosong() (
currentTime = millis();
if(currentTime >= (loopTime + 5))( // semak keadaan setiap 5ms (frekuensi 200 Hz)
pengekod_A = digitalRead(pin_A); // baca keadaan output A pengekod
pengekod_B = digitalRead(pin_B); // output pengekod B
if((!encoder_A) && (encoder_A_prev))( // jika keadaan berubah daripada positif kepada sifar
jika(pengekod_B) (
// output B berada dalam keadaan positif, yang bermaksud putaran mengikut arah jam
// meningkatkan kecerahan cahaya, tidak lebih daripada 255
jika(kecerahan + fadeAmount )
lain (
// output B berada dalam keadaan sifar, yang bermaksud putaran adalah lawan jam
// mengurangkan kecerahan, tetapi tidak di bawah sifar
if(brightness - fadeAmount >= 0) brightness -= fadeAmount;
}
}
pengekod_A_sebelumnya = pengekod_A; // simpan nilai A untuk gelung seterusnya
AnalogWrite(9, kecerahan); // tetapkan kecerahan kepada pin kesembilan
LoopTime = Masa semasa;
}
}
Dalam contoh pemula ini, kita akan melihat bekerja dengan pemancar piezo untuk menghasilkan bunyi. Untuk melakukan ini, mari kita ambil penderia piezoelektrik yang membolehkan kita menjana bunyi ombak dalam julat frekuensi 20 Hz - 20 kHz.
Ini adalah reka bentuk radio amatur di mana LED terletak di seluruh volum keseluruhan. Menggunakan litar ini, anda boleh menjana pelbagai cahaya dan kesan animasi. litar kompleks malah mampu memaparkan pelbagai perkataan tiga dimensi. Dalam erti kata lain, ini ialah pemantau keliling asas
Pemacu servo adalah elemen utama dalam reka bentuk pelbagai model kawalan radio, dan kawalannya menggunakan pengawal adalah mudah dan mudah.
Program kawalan adalah mudah dan intuitif. Ia bermula dengan memasukkan fail yang mengandungi segala-galanya perintah yang diperlukan untuk mengawal pemacu servo. Seterusnya, kami mencipta objek servo, contohnya servoMain. Fungsi seterusnya setup(), di mana kami menentukan bahawa servo disambungkan ke pin kesembilan pengawal.
Kod:
/*
Servo Arduino
*/
#termasuk
Servo servoMain; // Objek Servo
Persediaan tidak sah()
{
servoMain.attach(9); // Servo disambungkan ke pin 9
}
gelung kosong()
{
servoMain.write(45); // Putar servo ke kiri 45°
kelewatan(2000); // Tunggu 2000 milisaat (2 saat)
servoMain.write(0); // Putar servo ke kiri sebanyak 0°
kelewatan(1000); // Jeda 1 s.
kelewatan(1500); // Tunggu 1.5 s.
servoMain.write(135); // Putar servo ke kanan 135°
kelewatan(3000); // Jeda 3 s.
servoMain.write(180); // Putar servo ke kanan 180°
kelewatan(1000); // Tunggu 1 saat.
servoMain.write(90); // Putar servo 90°. Kedudukan pusat
kelewatan(5000); // Jeda 5 s.
}
Dalam fungsi utama gelung(), kami memberi arahan kepada servomotor, dengan jeda di antara mereka.
Litar pembilang Arduino pada penunjuk 7-segmen |
Projek Arduino mudah untuk pemula ini melibatkan mencipta litar pembilang menggunakan paparan katod biasa 7-segmen biasa. Kod program di bawah membolehkan anda mula mengira dari 0 hingga 9 apabila anda menekan butang.
Penunjuk tujuh segmen - adalah gabungan 8 LED (yang terakhir bertanggungjawab untuk titik) dengan katod biasa, yang boleh dihidupkan dalam urutan yang dikehendaki supaya mereka mencipta nombor. Perlu diingatkan bahawa dalam litar ini, lihat rajah di bawah, pin 3 dan 8 diperuntukkan kepada katod.
Di sebelah kanan ialah jadual surat-menyurat antara pin Arduino dan pin penunjuk LED.
Kod untuk projek ini:
nombor bait = (
B11111100, B01100000, B11011010, B11110010, B01100110,
B10110110, B10111110, B11100000, B11111110, B11100110
};
persediaan batal() (
for(int i = 2; i pinMode(i, OUTPUT);
}
pinMode(9, INPUT);
}
pembilang int = 0;
bool go_by_switch = benar;
int last_input_value = RENDAH;
gelung kosong() (
jika(go_by_switch) (
int suis_input_value = digitalRead(9);
if(nilai_masukan_akhir == RENDAH && nilai_input_suis == TINGGI) (
}
last_input_value = suis_input_value;
) lain (
kelewatan(500);
pembilang = (pembilang + 1) % 10;
}
writeNumber(counter);
}
Void writeNumber(int number) (
jika(nombor 9) (
kembali;
}
topeng bait = nombor;
bait semasaPinMask = B10000000;
for(int i = 2; i if(mask & currentPinMask) digitalWrite(i,HIGH);
lain digitalWrite(i,LOW);
currentPinMask = currentPinMask >> 1;
}
}
Anda boleh mengembangkan potensi papan Arduino dengan ketara dengan bantuan modul tambahan yang boleh disambungkan ke pin PIN hampir mana-mana peranti. Pertimbangkan modul pengembangan yang paling popular dan menarik, atau perisai kerana ia juga dipanggil.
Anda perlu
- Papan UNO Arduino;
- Kabel USB (USB A - USB B);
- Komputer peribadi;
- Diod pemancar cahaya;
- sepasang wayar penyambung 5-10 cm panjang;
- jika ada - papan roti.
Muat turun persekitaran pembangunan Arduino (Arduino IDE) daripada tapak web rasmi untuk sistem pengendalian anda (Windows, Mac OS X, Linux disokong). Anda boleh memilih pemasang ( Pemasang), anda boleh mengarkibkan ( Fail ZIP untuk pemasangan bukan pentadbir). Dalam kes kedua, program ini hanya dilancarkan dari folder, tanpa pemasangan. Fail yang dimuat turun mengandungi, sebagai tambahan kepada persekitaran pembangunan, pemacu untuk papan keluarga Arduino.
Muat turun Arduino IDE dari laman web rasmi
2 Sambungan Arduino ke komputer
Sambungkan papan Arduino dengan melalui USB kabel ( Jenis USB-A- USB-B) ke komputer. LED HIDUP hijau pada papan harus menyala.
Kabel USB-A ke USB-B untuk Sambungan Arduino ke komputer 3 Pemasangan pemandu untuk Arduino
Pasang pemacu untuk Arduino. Pertimbangkan pilihan pemasangan pada sistem pengendalian Windows. Untuk melakukan ini, tunggu sehingga sistem pengendalian meminta anda memasang pemacu. Tolak. Tekan kekunci Menang+Jeda, lari Pengurus peranti. Cari bahagian "Pelabuhan (COM dan LPT)". Anda akan melihat pelabuhan di sana dengan nama Arduino UNO (COMxx). klik Klik kanan tetikus padanya dan pilih Kemas kini pemandu. Beritahu sistem pengendalian lokasi pemandu. Ia terletak dalam subdirektori pemandu dalam folder yang baru kami muat turun.
Perhatikan port di mana papan Arduino disambungkan. Untuk mengetahui nombor port, lancarkan Pengurus Peranti dan cari bahagian "Port (COM dan LPT)". Nombor port akan ditunjukkan dalam kurungan selepas nama papan. Jika papan itu tiada dalam senarai, cuba putuskan sambungannya daripada komputer dan tunggu beberapa saat, kemudian sambungkannya semula.
Arduino dalam Pengurus Peranti Windows 4 tetapan Arduino IDE
Halakan persekitaran pembangunan anda ke papan anda. Untuk melakukan ini dalam menu Papan Alatan pilih Arduino UNO.
Pilih papan Arduino UNO dalam tetapan Tentukan nombor port COM yang papan Arduino disambungkan: Pelabuhan Alat.
Tetapkan port bersiri di mana papan Arduino disambungkan 5 Buka contoh program
Persekitaran pembangunan sudah mengandungi banyak contoh program untuk mengkaji operasi lembaga. Buka contoh "Blink": Sampel Fail 01.Asas Blink.Dengan cara ini, program untuk Arduino dipanggil "lakaran".
Buka lakaran contoh untuk Arduino 6 Pemasangan litar dengan LED
Putuskan sambungan Arduino daripada komputer. Pasang litar seperti yang ditunjukkan dalam rajah. Sila ambil perhatian bahawa kaki pendek LED mesti disambungkan ke pin GND, kaki panjang ke pin digital "13" papan Arduino. Mudah digunakan lembaga pembangunan, tetapi jika tiada, sambungkan wayar dengan memutar.
Pin digital "13" mempunyai perintang terbina dalam pada papan. Oleh itu, apabila menyambungkan LED ke papan, tidak perlu menggunakan perintang pengehad arus luaran. Apabila menyambungkan LED ke mana-mana pin Arduino yang lain, perlu menggunakan perintang, jika tidak, anda akan membakar LED, dan dalam kes yang paling teruk, port Arduino yang LED disambungkan!
Gambar rajah sambungan LED ke Arduino dalam memori Arduino
Kini anda boleh memuatkan atur cara ke dalam memori papan. Sambungkan papan ke komputer, tunggu beberapa saat sementara papan dimulakan. Klik butang Muat turun, dan lakaran anda akan ditulis pada ingatan papan Arduino. LED sepatutnya mula berkelip ceria pada anda setiap 2 saat (1 saat dihidupkan, 1 saat dimatikan). Di bawah ialah kod untuk program Arduino pertama kami.
persediaan batal() (// blok permulaan pinMode(13, OUTPUT); // tetapkan pin 13 sebagai output. } gelung kosong() (// gelung yang berulang tanpa henti selagi papan dihidupkan: digitalWrite(13, HIGH); // hantar ke pin 13 tahap tinggi- nyalakan kelewatan LED(1000); // untuk 1000 ms = 1 saat. digitalWrite(13, RENDAH); // hantar ke pin 13 Level rendah- matikan kelewatan LED(1000); // selama 1 saat. } // kemudian kitaran berulangBaca komen dalam teks program - ia sudah cukup untuk memahami percubaan pertama kami. Mula-mula kita menerangkan blok permulaan persediaan(), di mana kami menetapkan nilai awal pembolehubah dan fungsi pin Arduino. Satu gelung yang tidak berkesudahan menyusul gelung(), yang berulang berulang kali selagi kuasa dibekalkan kepada papan. Dalam kitaran ini kita melakukan segala-galanya tindakan yang perlu. Dalam kes ini, kami menghidupkan dan mematikan LED. Operator kelewatan() menentukan tempoh pelaksanaan (dalam milisaat) bagi pernyataan sebelumnya. Operator digitalWrite() memberitahu Arduino pin mana untuk menggunakan voltan, dan tahap voltan. Lakaran pertama anda sudah sedia!
Terdapat banyak tapak di Internet khusus untuk bekerja dengan papan keluarga Arduino. Baca, tuan, jangan takut untuk mencuba dan belajar perkara baru! Ini adalah aktiviti yang menyeronokkan dan bermanfaat yang akan membawa anda banyak keseronokan.
Nota
Berhati-hati apabila bekerja dengan papan Arduino - ini adalah produk elektronik yang memerlukan pengendalian yang teliti. Terdapat konduktor terdedah di bahagian bawah papan, dan jika anda meletakkan papan pada permukaan konduktif, terdapat peluang untuk membakar papan. Juga, jangan sentuh papan dengan tangan yang lembap atau basah dan elakkan kawasan lembap semasa bekerja.
Artikel ini akan membantu anda bermula dengan Arduino dan termasuk penerangan pelbagai jenis Arduino, cara memuat turun persekitaran pembangunan perisian Arduino, dan menerangkan pelbagai papan dan aksesori yang tersedia untuk Arduino yang anda perlukan untuk membangunkan projek Arduino.
Arduino ialah pengawal papan tunggal sumber terbuka yang boleh digunakan dalam pelbagai pelbagai aplikasi. Ini mungkin pilihan mikropengawal yang paling mudah dan paling murah untuk penggemar, pelajar dan profesional untuk membangunkan projek berasaskan mikropengawal. Papan Arduino menggunakan sama ada mikropengawal AVR Atmel atau mikropengawal ARM Atmel, dan sesetengah versi mempunyai antara muka USB. Mereka juga mempunyai enam atau lebih pin input analog dan empat belas atau lebih pin input/output digital (I/O), yang digunakan untuk menyambungkan penderia, penggerak dan litar persisian lain kepada mikropengawal. Harga papan Arduino, bergantung pada set fungsi, berkisar antara enam hingga empat puluh dolar.
Jenis papan Arduino
Terdapat pelbagai jenis papan Arduino, seperti yang ditunjukkan dalam senarai di bawah, masing-masing mempunyai set ciri mereka sendiri. Mereka berbeza dalam kelajuan pemprosesan, memori, port I/O dan kesambungan, tetapi fungsi teras tetap sama.
- Robot Arduino
- Arduino Ethernet
Anda boleh melihat kepelbagaian papan Arduino dan penerangan teknikalnya dalam subseksyen "" bahagian "Beli" di tapak ini.
Perisian (IDE)
Perisian yang digunakan untuk memprogramkan Arduino ialah Arduino IDE. IDE ialah Aplikasi Java, yang berfungsi pada set pelbagai platform, termasuk sistem PC, Mac dan Linux. Ia direka untuk pemula yang tidak biasa dengan pengaturcaraan. Ia termasuk editor, pengkompil dan pemuat. IDE juga termasuk perpustakaan kod untuk menggunakan peranti seperti port bersiri dan pelbagai jenis paparan. Program Arduino dipanggil "lakaran" dan ditulis dalam bahasa yang hampir sama dengan C atau C++.
Kebanyakan papan Arduino bersambung ke komputer menggunakan wayar USB. Sambungan ini membolehkan anda memuat naik lakaran ke papan Arduino anda dan juga memberikan kuasa kepada papan.
Kabel USB untuk Arduino
Pengaturcaraan
Pengaturcaraan Arduino adalah mudah: anda mula-mula menggunakan editor kod IDE untuk menulis program, kemudian menyusun dan memuat naiknya dengan satu klik.
Program Arduino merangkumi dua fungsi utama:
- persediaan()
- gelung()
Anda boleh menggunakan fungsi persediaan() untuk memulakan tetapan papan. Fungsi ini dilakukan sekali sahaja, apabila papan dihidupkan.
Fungsi gelung() berjalan selepas fungsi persediaan() selesai, dan tidak seperti fungsi persediaan(), ia berjalan secara berterusan.
Fungsi program
Di bawah ialah senarai fungsi yang paling biasa digunakan semasa pengaturcaraan Arduino:
- pinMode - menetapkan pin kepada mod input atau output;
- analogRead - membaca voltan analog pada pin input analog;
- analogWrite - menulis voltan analog ke pin keluaran analog;
- digitalRead - membaca nilai pin input digital;
- digitalWrite - menetapkan nilai pin output digital kepada tinggi atau rendah;
- Serial.print - menulis data ke port bersiri dalam teks ASCII yang boleh dibaca manusia.
Perpustakaan Arduino
Perpustakaan Arduino ialah koleksi fungsi yang membolehkan anda mengawal peranti. Berikut adalah beberapa perpustakaan yang paling banyak digunakan:
- EEPROM - membaca dan menulis ke storan "kekal";
- Ethernet - untuk menyambung ke Internet menggunakan papan Arduino Ethernet Shield;
- Firmata - untuk berkomunikasi dengan aplikasi pada komputer menggunakan protokol bersiri standard;
- GSM - untuk menyambung ke rangkaian GSM/GRPS menggunakan kad GSM;
- LiquidCrystal - untuk mengawal paparan kristal cecair (LCD);
- SD - untuk membaca dan menulis kad SD;
- Servo - untuk mengawal servos;
- SPI - untuk komunikasi dengan peranti menggunakan bas SPI;
- SoftwareSerial - untuk komunikasi bersiri melalui sebarang pin digital;
- Stepper - untuk mengawal motor stepper;
- TFT - untuk melukis teks, imej dan bentuk pada skrin TFT Arduino;
- WiFi - untuk menyambung ke Internet menggunakan papan WiFi Arduino perisai;
- Wayar - antara muka dua wayar (TWI/I2C) untuk menghantar dan menerima data melalui rangkaian peranti atau penderia.
Langkah Persediaan Arduino
Nota: Anda mungkin perlu memasang pemacu jika sistem anda tidak mengesan Arduino.
