ArduFarmBot Bagian 2: Membangun Stasiun Kontrol IoT Jarak Jauh
Komponen dan Perlengkapan
Arduino Nano R3
1
Espressif ESP8266 ESP-01
1
Sensor Suhu DHT22
1
ky18
1
hygrometer
1
Relay (generik)
2
lcd 4X20
1
Tombol Pushbutton SparkFun 12mm
3
LED (generik)
3
Aplikasi dan Layanan Online
ThingSpeak API
Tentang Proyek Ini
Tutorial ini adalah lanjutan dari ArduFarmBot: Mengontrol Kebun Tomat Rumah menggunakan Arduino dan IoT
Pada bagian pertama, kami membuat stasiun kontrol lokal, menangkap informasi dari kebun tomat, seperti suhu, kelembaban udara relatif, cahaya, dan kelembaban tanah. Berdasarkan data tersebut, ArduFarmBot secara otomatis menentukan jumlah yang tepat (dan kapan) kebun harus menerima panas dan air. Stasiun lokal yang dikembangkan pada Bagian 1 juga memungkinkan intervensi manual dari operator untuk mengontrol pompa air dan lampu listrik. Pada Bagian 2 ini, kami akan menerapkan pendekatan IoT di mana intervensi "manual" ini juga akan mungkin secara jarak jauh melalui Internet. Diagram blok menunjukkan bagaimana kami akan melakukannya.
Perhatikan bahwa data yang ditangkap akan dikirim ke "Cloud Storage service" (dalam hal ini Thinkspeak.com). Juga situs web khusus, "Remote Control Page" akan memantau dan menampilkan data tersebut dalam waktu nyata. Halaman web ini juga akan mengizinkan aktivasi pompa dan lampu secara jarak jauh.
Langkah 1: Daftar Bahan
Arduino Nano - ($7.50)
Sensor Suhu dan Kelembaban DHT22 atau DHT11 - ($3.66)
Sensor Cahaya - Modul Photo resistor AD-018. atau setara - ($0.71)
2X Sensor Kelembaban Tanah - ($1.99) (Opsional, bisa DIY)
LCD I2C 20X4 ($13.99)
LEDs (1X) ($0.20)
Modul Transceiver Nirkabel Serial Esp8266 Esp-01 - ($5.96)
Buzzer Aktif - Ky-12 atau setara ($0.60)
2 X Modul Relay 5v ($11.60)
Kabel Jumper (S1.00)
Resistor 10KOhm - ($0.03)
Resistor 2.2K Ohm - ($0.03)
Resistor 1.0K Ohm - ($0.03)
Resistor 220 Ohm - ($0.03)
Shield Arduino Nano ("Funduino") - ($7.28)
Keyboard Membran (4 Kunci) - ($6.65)
Kotak Plastik
Langkah 2: Menyelesaikan Hardware
Dimulai dari Stasiun Lokal yang dikembangkan pada Bagian 1, satu-satunya HW tambahan yang dibutuhkan adalah ESP8266. Diagram blok di atas menunjukkan semua koneksi PIN Arduino dan komponen utama. Perhatian satu-satunya yang harus Anda miliki terkait dengan tingkat tegangan. ESP8266 bekerja dengan 3.3V, jadi Pin Rx tidak boleh dihubungkan langsung ke Pin Tx Nano (D3). Sebuah pengubah tingkat tegangan harus digunakan. Dalam kasus kami, kami akan membuat pembagi tegangan untuk digunakan sebagai pengubah tingkat tegangan. Diagram di atas menunjukkan lebih detail cara menghubungkan ESP8266. Jika Anda ingin mengetahui lebih lanjut tentang ESP8266, silakan lihat tutorial saya:
The ESP8266 Part 3 - Memicu LED Arduino Secara Jarak Jauh
The ESP8266 Part 1 - Modul Serial WIFI untuk Arduino
The ESP8266 Part 2 - Web Server Arduino
Perhatikan bahwa kami menggunakan ESP8266 yang terhubung ke Pin Nano 2 (Tx) dan Pin 3 (Rx), menggunakan library SoftSerial. Jika Anda ingin "melepaskan" pin digital tersebut, Anda dapat secara bergantian menggunakan pin Serial Nano 0 dan 1. Hanya ingat bahwa Anda harus memutuskannya saat mengunggah kode ke Nano.
CATATAN: Jika Anda ingin menghubungkan BUZZER, Anda harus melakukannya di pin D17 (sama dengan pin A3). Baik untuk memiliki suara ketika terjadi kesalahan komunikasi. Saya menggunakannya selama fase pengujian, meninggalkan di proyek akhir (hw, tetapi kode siap untuk itu). Tergantung pada Anda untuk memilikinya atau tidak.
Anda dapat menggunakan kode di bawah ini untuk pengujian dan/atau penyiapan ESP8266 Anda:
FC9DBPKIT682FY7.ino
Langkah 3: Koneksi ESP8266
Untuk menghubungkan ArduFarmBot ke Internet, kami akan menggunakan ESP8266, modul sederhana, murah, dan mudah diprogram untuk proyek IoT. Setelah modul terpasang, hal pertama yang harus dilakukan adalah menerapkan "Reset" pada pin CH-PD-nya.
/*************************************************** * Fungsi Reset untuk menerima komunikasi ****************************************************/ void reset8266(void) { pinMode(CH_PD, OUTPUT); digitalWrite(CH_PD, LOW); delay(300); digitalWrite(CH_PD, HIGH); Serial.print("8266 reset OK"); lcd.clear(); lcd.println("8266 reset OK "); }
Setelah me-reset, mari hubungkan ke jaringan lokal Anda menggunakan kredensial Anda (dalam kode, ubah: USERNAME dan PASSWORD) dan inisialisasi modul sebagai "STA: Station Mode" (CWMODE = 1):
Untuk mengirim data ke ESP8266, fungsi sendData() digunakan:
/*************************************************** * Kirim perintah AT ke modul ****************************************************/ String sendData(String command, const int timeout, boolean debug) { String response = ""; esp8266.print(command); long int time = millis(); while ( (time + timeout) > millis()) { while (esp8266.available()) { char c = esp8266.read(); response += c; } } if (debug) { Serial.print(response); } return response; }
Fungsi di atas akan dipanggil selama "Setup Phase" dari Kode kami. Jika semuanya dilakukan dengan benar, Anda seharusnya melihat pesan serupa di Serial Monitor seperti di atas.
Langkah 4: Penyimpanan Data Cloud: ThinkSpeak.com
Semua data yang ditangkap oleh ArduFarmBot akan diunggah ke cloud, menggunakan layanan gratis "ThinkSpeak.com".
Pada fungsi "Loop()" (setelah kita menangkap data dengan readSensors()), kami akan memanggil fungsi spesifik untuk mengunggah data yang ditangkap: updateDataThingSpeak();
/*************************************************** * Transmit data ke thingspeak.com ****************************************************/ void updateDataThingSpeak(void) { startThingSpeakCmd (); cmd = msg ; cmd += "&field1="; //field 1 untuk suhu DHT cmd += tempDHT; cmd += "&field2="; //field 2 untuk kelembaban DHT cmd += humDHT; cmd += "&field3="; //field 3 untuk cahaya LDR cmd += lumen; cmd += "&field4="; //field 4 untuk data Kelembaban Tanah cmd += soilMoist; cmd += "&field5="; //field 5 untuk Status POMPA cmd += pumpStatus; cmd += "&field6="; //field 6 untuk Status LAMPU cmd += lampStatus; cmd += "\r\n"; sendThingSpeakCmd(); }
Untuk mengirim data tersebut, hal pertama yang harus dilakukan adalah memulai komunikasi dengan ThingSpeak. Kami akan melakukannya menggunakan fungsi: startThingSpeakCmd ();
/*************************************************** * Mulai komunikasi dengan ThingSpeak.com ****************************************************/ void startThingSpeakCmd(void) { cmd = "AT+CIPSTART=\"TCP\",\"\""; cmd += IP; cmd += "\",80"; esp8266.println(cmd); delay(2000); if(esp8266.find("Error")) { Serial.println("ESP8266 START ERROR"); return; } Serial.println("Thinkspeak Comm Started"); cmd =""; }
Setelah saluran terbuka dengan ThingSpeak dan string "cmd" dirangkaikan dengan data, saatnya untuk mengunggah semuanya ke saluran yang sesuai di ThingSpeak menggunakan fungsi: sendThingSpeakCmd();
Fungsi di atas didasarkan pada tutorial yang hebat dan detail yang dikembangkan oleh Michalis Vasilakis. Untuk detail lebih lanjut, silakan lihat tutorialnya: Arduino IOT: Suhu dan Kelembaban (dengan ESP8266 WiFi).
Foto menunjukkan saluran ArduFarmBot di ThingSpeak.com.
Langkah 5: Mengontrol Aktuator dari Web
Pada saat ini kami mengunggah semua data yang dikumpulkan dan menyimpannya di cloud. Ini sangat baik dan berguna untuk pemantauan jarak jauh, tapi bagaimana jika berdasarkan data tersebut kami juga ingin menyalakan Pompa atau Lampu, terlepas dari program otomatis lokal? Untuk melakukannya, kami juga perlu "Mengunduh" data dari Cloud dan memerintahkan pengontrol untuk bertindak berdasarkan perintah tersebut.
Kami akan membuat field spesifik pada saluran ThinkSpeak kami untuk mengontrol aktuator:
Field 7:
Data = 1 ==> POMPA harus Dinyalakan
Data = 0 ==> POMPA harus Dimatikan
Field 8:
Data = 1 ==> LAMPU harus Dinyalakan
Data = 0 ==> LAMPU harus Dimatikan
OK, tapi bagaimana cara menyiapkan field tersebut langsung di ThingSpeak? Kami dapat melakukannya, misalnya dengan menulis "PlugIn" langsung di ThinksPeak, atau kami dapat menggunakan situs web eksternal untuk melakukannya (ini akan menjadi pilihan kami). Bagaimanapun, pada kedua kasus Anda harus menggunakan perintah seperti:
Dengan perintah di atas, misalnya (dan menggunakan Channel Write Key Anda), Anda akan menulis "1" di field 7, yang berarti POMPA harus dinyalakan. Anda dapat dengan mudah mengujinya, mengetik baris perintah di atas di browser Anda, field yang sesuai di saluran Anda akan berubah. Sebagai kembalian, browser akan menunjukkan halaman putih dengan satu angka di sudut kiri atas, yang sesuai dengan entri data sekuensial di saluran Anda.
50% pekerjaan selesai, sekarang Anda harus membaca "perintah" ini (data pada field), di stasiun ArduFarmBot lokal Anda.
Perintah untuk melakukannya ditampilkan di bawah. Ini akan mendapatkan data terakhir yang ditulis di field tertentu (yang dalam kasus kami akan menjadi "perintah".
Cara yang sama seperti yang kami lakukan sebelumnya, Anda dapat menguji baris perintah, menggunakan browser web Anda. Dalam kasus ini, browser akan menunjukkan data pada field tertentu tersebut. Lihat Foto di atas.
Kembali ke "bumi", mari kita tulis fungsi yang akan membaca "field terakhir" ini:
/*************************************************** * Baca data dari field7 thingspeak.com ****************************************************/ int readLastDataField7() { startThingSpeakCmd (); cmd = msgReadLastDataField7; cmd += "\r\n"; String messageDown = sendThingSpeakCmd(); Serial.print("Command received: "); Serial.println(messageDown[7]); int command = messageDown[7]-48; return command; }
Fungsi di atas akan mengembalikan data pada field 7 ("1" atau "0"). Fungsi serupa harus ditulis untuk Field 8.
Setelah kita memiliki konten dari kedua field, kita harus menggunakannya pada fungsi yang akan mengintali aktuator secara serupa dengan yang kita lakukan dengan fungsi "manual command":
Jadi, mulai sekarang Anda dapat menggunakan baris perintah di browser Anda untuk Menyalakan/Mematikan Pompa dan Lampu secara jarak jauh. Foto di atas menunjukkan bagaimana perintah yang diterima akan muncul di Serial monitor Anda.
Pertimbangan penting lainnya adalah "koordinasi" antara perintah lokal dan jarak jauh. Kami harus mengubah fungsi readLocalCmd() untuk juga memperbarui Thinkspeak Field 7 dan 8 masing-masing dengan status Pompa dan lampu (pada pernyataan "IF" masing-masing. Lihat kode lengkap di akhir tutorial ini):
field7Data = pumpStatus; field8Data = lampStatus;
Sekarang "filed7Data" dan "field8Data" sinkron dengan perintah halaman web dan juga dengan tindakan perintah lokal ketika Anda menekan tombol. Jadi, mari kita perbarui fungsi aplyCmd(), yang bertanggung jawab untuk menyalakan/mematikan aktuator:
/*************************************************** * Terima Perintah dan bertindak pada aktuator ****************************************************/ void aplyCmd() { if (field7Data == 1) digitalWrite(PUMP_PIN, HIGH); if (field7Data == 0) digitalWrite(PUMP_PIN, LOW); if (field8Data == 1) digitalWrite(LAMP_PIN, HIGH); if (field8Data == 0) digitalWrite(LAMP_PIN, LOW); }
Saat Anda memulai pengujian, Anda akan menyadari bahwa setiap perintah yang Anda lakukan secara manual di lokal atau melalui web akan diatasi oleh tindakan otomatis yang didefinisikan oleh fungsi autoControlPlantation(); Pada titik ini Anda harus mempertimbangkan siapa yang akan menjadi "bos", yang memiliki kata terakhir! Dalam kasus kami di sini kami akan menentukan hal berikut:
Setiap siklus loop, yang hampir "selalu", kami akan melihat apakah tombol ditekan
Setiap menit, kami harus melakukan "pooling" di ThingSpeak dan melihat apakah kami telah menerima perintah dari sana.
Setiap 10 menit, kami akan membaca sensor, memperbarui data di ThingSpeak dan yang lebih penting lagi mengambil tindakan otomatis. Tindakan ini akan diambil terlepas dari apa yang dipilih secara manual dan akan menjadi yang dipertahankan.
Anda dapat mengubahnya, menurut keinginan Anda. Itu adalah hal baik tentang penggunaan prosesor yang dapat diprogram untuk mengontrol hal-hal!
Jadi, 2 timer akan digunakan sekarang, satu untuk pooling perintah jarak jauh dan satu lagi untuk membaca sensor (yang sama yang kami gunakan sebelumnya:
long sampleTimingSeconds = 75; int reverseElapsedTimeSeconds = 0; long startTiming = 0; long elapsedTime = 0; long poolingRemoteCmdSeconds = 20; long startRemoteCmdTiming = 0; long elapsedRemoteCmdTime = 0;
Jadi, fungsi loop() seharusnya sekarang ditulis ulang sebagai berikut:
Pada titik ini ArduFarmBot kami operasional dan dapat dikontrol dari web. Anda dapat memantau data di situs Thinkspeak dan juga mengirim perintah menggunakan browser, tetapi tentu solusi "web" ini tidak dapat dianggap "elegan"! Cara terbaik untuk menerapkan solusi IoT lengkap adalah mengembangkan halaman web lengkap yang akan menampilkan semua data, juga memiliki tombol untuk mengaktifkan aktuator.
Saya memilih Byethost, webhost gratis, sangat mudah dan sederhana untuk mengelola halaman Anda. Saya juga menggunakan kesempatan untuk menerapkan pada proyek ini, apa yang saya pelajari dari spesialisasi online yang hebat di Coursera/University of Michigan: Learn to Design and Create Websites (Build a responsive and accessible web portfolio using HTML5, CSS3, and JavaScript).
Saya tidak akan masuk ke detail bagaimana mengembangkan halaman tersebut, karena ini bukan tujuan utama tutorial ini, tetapi saya akan menyertakan di sini kode sumber HTML, CSS, dan JavaScript. Dan setelah ada orang yang tertarik bagaimana saya mendapatkan hasilnya, kita dapat membicarakannya terpisah menggunakan Board Komentar di akhir proyek.
Penting untuk ditekankan bahwa halaman ini tidak bekerja langsung dengan Stasiun Kontrol Lokal ArduFarmBot. Apa yang sebenarnya dilakukan adalah berinteraksi dengan saluran ThinkSpeak sebagai berikut:
Membaca data sensor pada field 1, 2, 3, 4
Membaca status aktuator pada field 5 dan 6
Menulis data pada field 7 dan 8
Membaca data cuaca lokal dari layanan Yahoo
Item 4 di atas tidak benar-benar krusial untuk proyek, tetapi selalu ada data tambahan yang tersedia jika Anda ingin mengambil beberapa tindakan jarak jauh terlepas dari apa yang terjadi secara lokal dengan kebun tomat Anda. Pertimbangan lain adalah Anda dapat, misalnya, menyimpan data tersebut di saluran ThingSpeak lain dan mengunduhnya ke Arduino Anda, menunjukkan data cuaca di layar LCD lokal (Saya mengembangkan ini di proyek keren lain yang berhasil! Saya meninggalkan di sini sebagai saran untuk Anda).
FQOK9ENIT653YX5.zip
Langkah 7: Kembali ke Otak. Pendekatan Matriks Sensor-Aktuator:
Pada bagian pertama dari proyek ini, kami telah menentukan beberapa pertimbangan awal tentang bagaimana aktuator harus bertindak tergantung pada bacaan sensor. Kami hanya membuat pilihan sederhana, tapi apa yang akan terjadi jika kita memiliki situasi yang lebih kompleks? Beberapa kondisi yang berbeda? Apa yang akan kami kembangkan adalah "pendekatan Matriks Sensor - Aktuator".
Pada Matriks yang didefinisikan untuk setiap sensor, kondisinya dan bagaimana keluaran aktuator harusnya. Hasilnya dapat dilihat pada spreadsheet Excel yang disertakan di bawah. Pada file Excel ada dua spreadsheet. Tabel dengan filter dan versi tempat Anda dapat memilih beberapa kondisi sensor dan melihat bagaimana aktuator akan bekerja karena pilihan ini.
Setelah Matriks didefinisikan, kita harus menterjemahkannya ke dalam kode kami. Sebuah array 18 baris dan 10 kolom dibuat untuk "menyalin" kondisi Matriks Sensor-Aktuator:
Untuk bekerja dengan Matriks, kami membuat fungsi defSensorStatus (). Fungsi ini menguji setiap baris jika kondisi 8 kolom pertama BENAR. Jika Ya, kondisi 2 kolom terakhir dieksekusi.
Contoh:
if (1 and 0 and 0 and 0 and 1 and 0 and 0 and 1) { pumpStatus = 1; lampStatus = 0} else if (1 and 0 and 0 and 0 and 1 and 0 and 1 and 0) { pumpStatus = 1; lampStatus = 0}
dan seterusnya.
Di dalam fungsi di atas, array lain dibuat dengan status dari setiap bacaan sensor:
Variabel array ini juga akan digunakan untuk LOG register.
F2HWXBYITA8WIN1.xlsx
Langkah 8: Optimasi Kode
Selama proses pengembangan ArduFarmBot kami menyadari bahwa beberapa perubahan pada spesifikasi asli harus dilakukan:
Display:
Layar LCD harus OFF secara default dan setiap kali bacaan sensor diperlukan kita dapat secara manual menyalakannya "ON". Kondisi ini diimplementasikan dalam kode dan tombol "Sensors Read" harus digunakan dalam mode "toggle" untuk Menyalakan/Mematikan LCD kapan saja. Menyalakan atau Mematikan layar akan memperbarui bacaan sensor untuk ditampilkan, tetapi tidak digunakan oleh ArduFarmBot pada fungsinya reguler.
Initial Setup:
Saat ArduFarmBot Dinyalakan (atau di-reset), LCD akan menampilkan "Initial Set-up". Untuk memulai menjalankan program, tombol "Sensors" harus ditekan. Informasi awal (lihat foto di atas) yang ditampilkan adalah:
Suhu DINGIN (mis. 12oC)
Kelembaban Tanah KERING (mis. 30%)
Kelembaban Tanah BASAH (mis. 60%)
Cahaya GELAP (mis. 40%)
P_ON Pompa waktu ON (mis. 10s)
SCAN Waktu untuk membaca sensor (mis. 600s)
SW_Version (mis. 4.1)
Log Record:
Untuk tujuan audit, kami telah membuat LOG dengan bacaan dan aktuasi ArduFarmBot kami. Pada setiap siklus pembacaan, fungsi: storeDataLogEEPROM() dieksekusi.
Seperti yang dikomentari pada Langkah terakhir, yang akan disimpan di Arduino EEPROM adalah isi, bit demi bit, dari array snsSts[] ditambah status Pompa dan Lampu. Di atas Anda dapat melihat LOG di Serial Monitor.
Semua kode ArduFarmBot dibagi menjadi berkas berbeda agar lebih mudah dipahami. Perhatikan bahwa 2 berkas baru ditambahkan pada bagian kedua ini:
communication.ino (fungsi spesifik ThingSpeak dan ESP8266)
stationCredentials.h (Channel ID ThingSpeak dan Kunci spesifik untuk menulis di saluran)
Terakhir dan tidak kurang penting, setelah kode berakhir dengan ukuran yang wajar, kami memutuskan untuk menyimpan data konstan di memori flash (program) bukan SRAM. Untuk itu, kami menggunakan kata kunci PROGMEM yang merupakan pengubah variabel. Sebagai contoh, alih-alih menggunakan:
#define DHTPIN 5
Kami menggunakan:
const PROGMEM byte DHTPIN = 5;
Kata kunci PROGMEN memberitahu kompiler "masukkan informasi ini ke memori flash", alih-alih ke SRAM, tempatnya biasanya akan pergi. Anda juga harus menyertakan library avr/pgmspace.h di berkas utama kode Anda.
Prosedur baik lainnya untuk mengurangi penggunaan SRAM adalah memberi komentar (atau menghapus) semua baris Serial.Print () yang Anda gunakan untuk debugging selama pengembangan. Anda akan menyadari bahwa kode yang digunakan untuk misalnya menampilkan LOG di Serial Monitor akan diberi komentar pada berkas di bawah ini.
Di bawah ini Anda dapat menemukan kode lengkap Arduino ArduFarmBot. Jangan lupa untuk mengubah data dummy di credentials.h dengan Channel Id dan Write Key Anda. Juga pada communication.ino, gunakan Username dan password asli Anda untuk menghubungkan ESP 8266 ke Internet.
Foto di bawah menunjukkan foto berurutan dari ArduFarmBot mengontrol Kebun Tomat Pertama saya.
Urutan foto di bawah menunjukkan evolusi kebun kedua saya dari penanam benih sampai waktu untuk memilih tanaman terbaik (sekitar 45 hari) dan transplantasi 6 tanaman terbaik.
Langkah 10: Kesimpulan
Itu saja ya! ...Sampai nanti!
Seperti biasa, saya harap proyek ini dapat membantu orang lain menemukan jalan mereka di dunia elektronik, IoT, dan Robotika yang menarik!
Segera kami mungkin akan menerbitkan bagian ketiga dan terakhir dari proyek ini yang saya harap akan menjadi resep yang sangat baik untuk pasta saus tomat organik.
Btw, pada foto di atas Anda dapat melihat tanda-tanda pertama kehidupan pada kebun Mauricio! Dan sebelum Anda pergi, silakan lihat ArduFarmBot, the book!, di mana saya mengemas semua proyek dalam format yang lebih ramah:
ArduFarmBot, the Book!
"ArduFarmBot, the book" juga di Amazon.com! Anda dapat mendapatkannya dengan mengklik di siniBuku menggunakan pengontrol elektronik ArduFarmBot sebagai dasar untuk mengajar cara bekerja baik di HW dan SW, dengan:
Layar jenis LCD dan OLED;
LED dan tombol;
Aktivasi pompa dan lampu melalui relay dan
Sensor seperti: DHT22 (suhu dan kelembaban udara relatif), DS18B20 (suhu tanah), YL69 (kelembaban tanah) dan LDR (cahaya).
Semua tahap kunci proyek didokumentasikan secara detail melalui teks penjelasan, diagram blok, foto warna resolusi tinggi, diagram listrik menggunakan aplikasi Fritzing, kode lengkap yang disimpan di GitHub dan video YouTube.
Dua versi pengontrol elektronik ArduFarmBot dikembangkan secara detail dalam buku. Dari tangkapan data yang datang dari kebun, seperti suhu udara dan tanah, kelembaban relatif, kelembaban tanah dan cahaya, ArduFarmBot membantu mengontrol kapan tanaman harus menerima panas dan air. Kontrol akan terjadi secara otomatis, lokal dan jarak jauh melalui internet. Buku dibagi menjadi 3 bagian. Pada bagian pertama, Arduino Nano adalah titik awal untuk pengembangan versi lokal ArduFarmBot, yang dapat dikontrol baik secara manual maupun otomatis.
Pada bagian kedua, buku menyelami desain otomatisasi, memperkenalkan operasi jarak jauh melalui pembuatan halaman web. ESP8266-01 digunakan untuk koneksi Wi-Fi, mengirim data ke layanan web penting di bidang IoT, ThingSpeak.com.
Pada bagian ketiga, versi kedua dari ArduFarmBot dikembangkan, memperkenalkan NodeMCU ESP8266-12E, perangkat IoT yang canggih dan serbaguna, yang menggantikan baik Arduino Nano dan ESP8266-01, yang digunakan pada bagian awal buku.
Pada bagian terakhir buku ini, platform layanan baru dari alam semesta IoT, Blynk, juga dijelajahi.
Unduh buku, beri ulasan dan silakan gunakan papan pesan di sini untuk memberikan komentar, saran atau kritik apa pun kepada kami!
Untuk proyek lainnya, silakan kunjungi blog saya: MJRoBot.org
Saludos from the south of the world!
See you at my next project!
Thank you
Marcelo
Kode
Code snippet #1
Code snippet #2
Code snippet #3
Code snippet #4
Code snippet #5
Code snippet #6
Code snippet #9
Code snippet #10
Code snippet #11
Code snippet #12
Code snippet #13
Code snippet #14
Code snippet #15
Code snippet #1Plain text
/*************************************************** * Fungsi Reset untuk menerima komunikasi ****************************************************/ void reset8266(void) { pinMode(CH_PD, OUTPUT); digitalWrite(CH_PD, LOW); delay(300); digitalWrite(CH_PD, HIGH); Serial.print("8266 reset OK"); lcd.clear(); lcd.println("8266 reset OK "); }
